javascript的in操作符用于判断某个名称的属性是否存在于某个对象的原型链中。
语法：
prop in object
prop是string类型或Symbol类型，其他类型会被转化为string，返回值是布尔值，如果object.prop存在则返回true，否则返回false。
需要注意的是，object必须是一个对象。最容易被误用的场景是对字符串使用in操作符，这将直接抛出一个异常：
> 'length' in 'mystring' // Uncaught TypeError: Cannot use 'in' operator to search for 'length' in mystring
如果要判断字符串是否包含另一个字符串，请使用includes方法（ES6）。
写C#窗口程序，今天遇到的问题。在工作线程（非UI线程）要操作ListView，因此使用了跨线程调用方式。
for (int i = 0; i < videos.Count; ++i)
{
this.BeginInvoke(new Action(() =>
{
var item = lvwVideos.FindItemWithText(videos[i]);
if (item != null)
lvwVideos.Items.Remove(item);
}));
}
代码一跑给我抛出了异常，数组下标越界。原因分析如下。
概念理解错误，C#的闭包环境并不会复制用到的局部变量。
.NET对闭包的实现是在编译阶段而不是运行阶段，事实上，匿名函数中的变量 i 和 for 循环中的i就是同一个变量，由于函数返回后变量还会被匿名函数使用，它会保存在堆中而不是调用栈——不管这个变量是值类型还是引用类型（如果是引用类型即对象和对象的引用都在堆中）。
因此，循环结束后 i 的值已经超出数组 videos 的下标范围。而BeginInvoke函数是不等待执行完毕的，因此很可能循环结束而匿名函数还没有执行完毕。这时匿名函数从堆中取到的 i 已经不是定义匿名函数时 i 的值了。
用下面的代码来说可能更清晰。
static void Main(string[] args)
{
int i = 1;
Action action = new Action(() =>
{
Console.WriteLine(i);
});
++i;
action(); // 2
}
action执行的时候访问的 i 和Main函数中的 i 是同一个，存储在堆中。
这里最简单的解决方法是将BeginInvoke改为Invoke。Invoke()会等待UI线程执行完毕才会继续执行，能够保证 i 值不会被工作线程改变。
将上面的代码稍作修改：
static void Main(string[] args)
{
int i = 1;
Action action = null;
new Action<int>((n) =>
{
action = new Action(()=>
{
Console.WriteLine(n);
});
})(i);
++i;
action(); // 1
}
这相当于将 i 复制了一遍。
前段时间心血来潮想学习最近的明星编程语言Golang。于是想做个聊天小程序实践一下。程序基于TCP协议通信，更详细的设计见设计思路。
用Golang实现了服务端程序，同时代码抄抄改改做了个Golang客户端，又由于输出问题，用C++写了个Windows控制台的简陋的输出控制库，于是客户端在Windows上能看了（不过朋友说很丑>_<）。
在朋友（@Billows）的鼓励下，我们决定用C#写一个客户端程序，正好他在学习WPF编程，于是界面采用了WPF编写。我负责后台数据交互，他负责前台界面逻辑。
C#客户端还使用到了JSON格式化库Newtonsoft.Json，特此说明。
github地址：https://github.com/mattuylee/stormchat
数据通信基于TCP协议，每次通信的数据包应包含【包头域+数据域】。包头域总是JSON格式、UTF-8编码的字符串，数据域由包头决定，可以为空。通信数据包结构如图。
HEAD（包头域）至少包含两个参数：
Token参数是一次通信的标识文本，由请求方随机生成，处理方返回数据包的Token参数应和请求方的Token参数一致（如果有返回数据）。
Operation参数指定本次通信的请求。它决定了数据包的其他数据。Operation具体行为定义见这里。
本来做了设计图表，不过第一次用starUML，画了一半才发现完全是鬼画桃符，没有掌握正确的作图方式，也没什么热情重新画了。因此这里不展示完整的设计文件了（本来也不完整），上面的链接是截取的关键部分（才知道starUML可以导出html文档）。
哦，还有服务器端的数据库结构，见文件stormchat-server/res/stormchat.sql。
由于懒癌发作，一些参数设置只能在编译时指定好，没有运行中指定参数的功能。
Go语言的部分（服务器程序和golang客户端程序）这块都在control.go文件中，C#客户端这边也没什么可配置的，也就是连接服务器的地址和端口。下面列出部分配置参数：
serveMode
服务（后台）模式。如果此参数为true，日志输出到str_log_file参数指定的文件中，且Debug()函数将不输出内容。如果为false，日志输出和Debug()函数都将直接向控制台或终端输出。
max_head_length
最大包头长度，单位字节，如果包头长度超过此参数将被抛弃。
max_message_length
最大消息长度，单位字节，如果消息长度超过此参数将被抛弃。
max_photo_size
最大头像大小，单位字节，如果头像数据长度超过此参数将被抛弃。
timeout_message
客户端连接最大数据等待时间，单位秒。如果超过此时间客户端没有数据到达则断开连接（此参数当前未启用）。
str_log_file
日志文件。仅在serveMode为true时有效。注意，程序并不会自动清理此文件。
str_db_conn_str
MySQL数据库连接字符串。
资源定义在StormChat解决方案，Interact项目的属性->资源中。
RemoteServerAddr
服务器地址。
RemoteServerPort
服务器端口。
首先安装git和golang，这一步请自行解决；
克隆项目到本地：
git clone -b master https://github.com/mattuylee/stormchat.git
假设项目已克隆到本地DIR目录，命令行切换到stormchat目录:
cd DIR/stormchat
cd stormchat-server
Go标准库里是没有数据库操作的库的，因此先添加mysql操作库到项目中。创建目录sotormchat-server/src/github.com/go-sql-driver/，然后克隆MySQL操作库：
cd src/github.com/go-sql-driver
git clone https://github.com/go-sql-driver/mysql.git
Windows下：
如果环境变量GOPATH存在，则在GOPATH后添加 ";DIR/stormchat/stormchat-server"(不含引号，注意分号)，如果不存在添加GOPATH环境变量并将其设置为DIR/stormchat/stormchat-server即可，注意把DIR换成git仓库所在目录。
Linux下:
先查看GOPATH环境变量的值，再添加项目目录到GOPATH：
echo $GOPATH
如果值为空：
export GOPATH=DIR/stormchat/stormchat-server
如果值不为空：
export GOPATH=$GOPATH:DIR/stormchat/stormchat-server
切换到stormchat-server/src/stormchat/目录，然后编译：
cd DIR/stormchat/stormchat-server/src/stormchat
go build
登录mysql：
mysql -uroot -p
为stormchat创建数据库：
CREATE DATABASE stormchat CHARSET=UTF8;
导入数据库结构:
SOURCE DIR/stormchat/stormchat-server/res/stormchat.sql;
创建用户并授权：
CREATE USER 'stormchat'@'localhost' IDENTIFIED BY 'stormchat';
GRANT ALL ON stormchat.* TO 'stormchat'@'localhost';
FLUSH PRIVILEGES;
Linux下执行下列命令以守护进程运行：
nohup ./stormchat &
Windows请自行探索。
cd DIR/stormchat/stormchat-client-golang/src
go build
注意，客户端运行时需要conctrl_x64.dll在运行目录下，此文件在stormchat-client-golang/res/目录下。
Visual Studio 2015以上版本打开项目，直接编译即可。
// 2018-12-08
// By Mattuy
// AVL树的C语言实现
// 实现对AVL树节点的增删改查
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int DataType; //树的数据域
//定义AVL树
typedef struct SearchTree
{
int height; //树的深度，空树（NULL）的深度为-1
DataType value;
struct SearchTree* left;
struct SearchTree* right;
} TreeNode, SearchTree;
TreeNode* SingleRotateWithLeft(TreeNode* grandpa); //左左单旋转
TreeNode* SingleRotateWithRight(TreeNode* grandpa); //右右单旋转
TreeNode* DoubleRotateWithLeft(TreeNode* grandpa); //左右双旋转
TreeNode* DoubleRotateWithRight(TreeNode* grandpa); //右左双旋转
TreeNode* Remove(SearchTree* tree, TreeNode* node); //删除节点
void Assign(TreeNode* dest, DataType* value); //将一个节点的值赋给另外一个节点
TreeNode* Find(SearchTree* tree, DataType value); //查找节点
//获取树高度
int getHeight(SearchTree* tree);
//删除同时有左右孩子的节点时寻找子合适的子节点来顶替被删除节点
TreeNode* findExtreamNode(TreeNode* node);
//中序遍历输出AVL树
void output(SearchTree* tree);
//左左单旋转
TreeNode* SingleRotateWithLeft(TreeNode* grandpa)
{
//将祖父变为父亲的右儿子，父亲原来的右儿子变为祖父的左儿子（祖父原来的左儿子就是父亲，关系已断开）
TreeNode* parent = grandpa->left;
grandpa->left = parent->right;
parent->right = grandpa;
//新的关系是，原来的孙子和祖父变成父亲的左右儿子（孙子位置没动）。
//原祖父(现父亲右儿子)的深度取决于原父亲的右儿子和原祖父的右儿子
//父亲的深度取决于孙子和祖父（现右儿子），因此须先计算祖父（右儿子）的深度
grandpa->height = max(getHeight(grandpa->left), getHeight(grandpa->right)) + 1;
parent->height = max(getHeight(parent->left), grandpa->height) + 1;
//返回新的根节点（原来是祖父，现在是父亲）
return parent;
}
//右右单旋转
TreeNode* SingleRotateWithRight(TreeNode* grandpa)
{
TreeNode* parent = grandpa->right;
grandpa->right = parent->left;
parent->left = grandpa;
grandpa->height = max(getHeight(grandpa->left), getHeight(grandpa->right)) + 1;
parent->height = max(getHeight(parent->right), grandpa->height) + 1;
return parent;
}
//左右双旋转
TreeNode* DoubleRotateWithLeft(TreeNode* grandpa)
{
grandpa->left = SingleRotateWithRight(grandpa->left);
return SingleRotateWithLeft(grandpa);
}
//右左双旋转
TreeNode* DoubleRotateWithRight(TreeNode* grandpa)
{
grandpa->right = SingleRotateWithLeft(grandpa->right);
return SingleRotateWithRight(grandpa);
}
//插入节点，返回插入后的根节点
TreeNode* Insert(SearchTree* tree, DataType value)
{
if (tree == NULL)
{
TreeNode* temp = (TreeNode*)malloc(sizeof(TreeNode));
if (!temp)
{
return NULL;
} //申请内存失败
temp->left = temp->right = NULL;
temp->value = value;
temp->height = 0;
return temp;
} //插入新节点
if (value < tree->value)
{
tree->left = Insert(tree->left, value);
//当平衡被破坏时调整
if (getHeight(tree->left) - getHeight(tree->right) == 2)
{
//插入的节点在哪边就旋转哪边
if (value < tree->left->value)
tree = SingleRotateWithLeft(tree);
else
tree = DoubleRotateWithLeft(tree);
}
}
else if (value > tree->value)
{
tree->right = Insert(tree->right, value);
if (getHeight(tree->right) - getHeight(tree->left) == 2)
{
if (value > tree->right->value)
tree = SingleRotateWithRight(tree);
else
tree = DoubleRotateWithRight(tree);
}
}
else
return NULL; //不允许插入值相同的节点
tree->height = max(getHeight(tree-> left), getHeight(tree->right)) + 1;
return tree;
}
//删除节点
TreeNode* Remove(SearchTree* tree, TreeNode* node)
{
if (!tree || !node)
return NULL;
if (node == tree)
{
if (tree->left && tree->right)
{
//找到一个合适的子节点来替换被删除的节点
TreeNode* leaf = findExtreamNode(tree);
//记录是在左子树找的子节点还是右子树
bool doesLeft = true;
if (leaf->value > tree->value)
doesLeft = false;
//用子节点的值替代要删除节点的值
Assign(tree, leaf->value);
//删除子节点。因为现在tree节点的值和子节点一样，所以不能直接传tree节点作为参数
if (doesLeft)
tree->left = Remove(tree->left, leaf);
else
tree->right = Remove(tree->right, leaf);
tree->height = max(getHeight(tree->left), getHeight(tree->right)) + 1;
return tree;
} //被删除的节点有两个儿子
else if (!tree->left && !tree->right)
{
free(tree);
return NULL;
} //被删除的是叶子节点
else if (tree->left || tree->right)
{
TreeNode* temp = tree->left ? tree->left : tree->right;
free(tree);
return temp;
} //被删除的节点只有一个儿子
} //当前节点为待删除节点
else if(node->value > tree->value)
{
tree->right = Remove(tree->right, node);
//如果删除节点后破坏平衡，调整以重新平衡
//从右子树删除节点后进行左旋转
//如果左孩子有左孩子则进行单旋转，否则进行双旋转
if (abs(getHeight(tree->left) - getHeight(tree->right)) == 2)
tree = tree->left->left ? SingleRotateWithLeft(tree) : DoubleRotateWithLeft(tree);
} //待删除节点在右子树
else
{
tree->left = Remove(tree->left, node);
//从左子树删除节点后进行右旋转
//如果右孩子有右孩子则进行单旋转，否则进行双旋转
if (abs(getHeight(tree->left) - getHeight(tree->right)) == 2)
tree = tree->right->right ? SingleRotateWithRight(tree) : DoubleRotateWithRight(tree);
} //待删除节点在左子树
tree->height = max(getHeight(tree->left), getHeight(tree->right)) + 1;
return tree;
}
//为节点赋值
void Assign(TreeNode* dest, DataType* value)
{
dest->value = value;
}
//查找
TreeNode* Find(SearchTree* tree, DataType value)
{
TreeNode* cur = tree;
while (cur != NULL)
{
if (cur->value == value)
break;
cur = value > cur->value ? cur->right : cur->left;
}
return cur;
}
//获取树高度
int getHeight(SearchTree* tree)
{
return tree ? tree->height : -1;
}
/**
* 当被删除节点有左右孩子时找出左子树的最右节点或右子树的最左节点。务必保证传入的参数为被搜索的节点，
* 函数将根据其左右子树的深度来决定返回左孩子的最右子树还是右孩子的最左子树。
* 此函数仅应被Remove函数调用
*/
TreeNode* findExtreamNode(TreeNode* node)
{
if (node->right->height > node->left->height)
{
TreeNode* cur = node->right;
while (cur->left)
cur = cur->left;
return cur;
}
else
{
TreeNode* cur = node->left;
while (cur->right)
{
cur = cur->right;
}
return cur;
}
}
//中序遍历输出
void output(SearchTree* tree)
{
if (!tree) return;
output(tree->left);
printf("value = %d, height = %d\n", tree->value, tree->height);
output(tree->right);
}
//测试
int main()
{
SearchTree* tree = NULL;
for (int i = 1; i <= 8; i++)
tree = Insert(tree, i);
tree = Remove(tree, Find(tree, 6));
output(tree);
system("pause");
}
今天做的题叫Two Sum，简单题，给定一个整形数组和一个整数target，存在唯一的两个成员相加等于target，要求返回这两个成员的位置。
示例：
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].
最简单的当然是暴力算法，一个嵌套的for循环搞定。标准答案如下：
public int[] twoSum(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[j] == target - nums[i]) {
return new int[] { i, j };
}
}
}
}
第一种方法的时间复杂度是O(n2)，空间复杂度O(1)。另一个更快的解决方案是利用哈希表。遍历数组并将成员其插入哈希表，再查询[target - 成员]是否在表中（不能等于自身），如果在则结果已产生。至于是一次遍历实现还是两次遍历个人认为区别不大。 标准答案如下：
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
map.put(nums[i], i);
}
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i];
if (map.containsKey(complement) && map.get(complement) != i) {
return new int[] { i, map.get(complement) };
}
}
}
哈希表最大的优势在于查询。理想的哈希表可以以O(1)的时间复杂度处理查询。此题的微妙之处在于，需要将数组索引作为表的值而数组成员作为键。而思维惯性可能让人一时转不过弯。
哈希表虽然高效，但却不是任何时候都适用。它的空间复杂度是O(n)，但其常数因子并不小，可能花费甚至浪费很大的空间。另外冲突处理也会一定程度降低哈希表的性能。
因此哈希表并不总是比暴力解法好。如果你的空间足够，数据量大，查询频度高，我认为使用哈希表是合理的选择。
注意，编译前源文件字符编码必须为GB2312/GBK。否则填充字符█会出现异常。
编译时需要指定按C++11标准编译，为了支持结构体字面量的语法。
g++ -std=c++11 -o gluttonous-snake.exe ./source.cpp
#include <cstdlib>
#include <conio.h>
#include <deque>
#include <iostream>
#include <time.h>
#include <windows.h>
//定义一次步进
typedef struct {
//是否纵向移动
bool virticle = false;
//移动步长
int offset = 0;
}Step;
//定义'成长礼包'类型
enum GiftType {
//礼物，增加长度
GIFT_GIFT = FOREGROUND_GREEN,
//陷阱，减少长度
GIFT_TRAP = FOREGROUND_GREEN | FOREGROUND_BLUE,
//利剑，直接死亡
GIFT_SWORD = FOREGROUND_RED
};
//定义移动区域。窗口宽度应为width的两倍，因为ansi字符宽度仅高度的1/2。
#define FACTORY_WIDTH 64
#define FACTORY_HEIGHT 36
//定义蛇身颜色
#define SNAKE_BODY_COLOR (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
using namespace std;
//控制台输出句柄
HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//蛇身数据容器。
deque<COORD> snakeBody;
//死亡标记
bool dead = false;
//'成长礼包'
COORD gift, trap, sword;
//判定点是否在蛇身上
bool inSnake(COORD point) {
if (snakeBody.size() == 0)
return false;
deque<COORD>::iterator iter = snakeBody.begin();
while (iter != snakeBody.end()) {
if (point.X == (*iter).X && point.Y == (*iter).Y)
return true;
++iter;
}
return false;
}
//生成'成长礼包'
COORD createGift(GiftType color) {
//统计递归调用次数
static int count = 0;
++count;
COORD point;
srand(rand());
point.X = rand() % FACTORY_WIDTH * 2;
srand(rand());
point.Y = rand() % FACTORY_HEIGHT;
if (inSnake(point)) {
return createGift(color);
}
else {
SetConsoleCursorPosition(hOutput, point);
SetConsoleTextAttribute(hOutput, color);
cout << "█";
SetConsoleTextAttribute(hOutput, SNAKE_BODY_COLOR);
dead = count > 12 ? true : false;
count = 0;
return point;
}//连礼包都没地方放了，死了算了
}
//初始化
void init() {
system("cls");
snakeBody.clear();
srand(time(NULL));
snakeBody.push_front({ 0, 0 });
snakeBody.push_front({ 2, 0 });
snakeBody.push_front({ 4, 0 });
deque<COORD>::iterator iter = snakeBody.begin();
while (iter != snakeBody.end()) {
SetConsoleCursorPosition(hOutput, *iter);
cout << "█";
++iter;
}
sword = createGift(GIFT_SWORD);
trap = createGift(GIFT_TRAP);
gift = createGift(GIFT_GIFT);
}
//步进
void stepOnece(Step step) {
COORD head = snakeBody.front();
(step.virticle ? head.Y : head.X) += step.offset;
//死亡
if (inSnake(head)
|| snakeBody.size() == 0
|| (head.X == sword.X && head.Y == sword.Y)
|| head.X < 0 || head.X >= FACTORY_WIDTH * 2
|| head.Y < 0 || head.Y >= FACTORY_HEIGHT) {
dead = true;
return;
}
snakeBody.push_front(head);
SetConsoleCursorPosition(hOutput, head);
cout << "█";
int count;
if (head.X == trap.X && head.Y == trap.Y) {
count = 2;
trap = createGift(GIFT_TRAP);
}//陷阱，变短
else if (head.X == gift.X && head.Y == gift.Y) {
count = 0;
gift = createGift(GIFT_GIFT);
}//礼物，增长
else
count = 1;
for (int i = 0; i < count; i++) {
COORD back = snakeBody.back();
SetConsoleCursorPosition(hOutput, back);
printf(" ");
snakeBody.pop_back();
if (snakeBody.size() == 0) {
dead = true;
break;
}
}
}
//控制循环
void gameLoop() {
Step curStep = { false, 2 };
Step step = curStep;
while (!dead) {
for (int i = 0; i < 200; i++) {
Sleep(1);
if (!_kbhit())
continue;
char cmd;
bool breakdown = true;
cmd = _getch();
switch (cmd) {
case 'w':
step.virticle = true;
step.offset = -1;
break;
case 's':
step.virticle = true;
step.offset = 1;
break;
case 'a':
step.virticle = false;
step.offset = -2;
break;
case 'd':
step.virticle = false;
step.offset = 2;
break;
default:
breakdown = false;
break;
}
//禁止当前方向反方向步进
if (step.virticle == curStep.virticle && step.offset * curStep.offset < 0)
continue;
else
curStep = step;
if (breakdown)
break;
}
stepOnece(curStep);
}
}
int main() {
//设置缓冲区大小
SMALL_RECT rect = { 0, 0, 10, 10 };
SetConsoleWindowInfo(hOutput, true, &rect);
SetConsoleScreenBufferSize(hOutput, { FACTORY_WIDTH * 2, FACTORY_HEIGHT });
//设置窗口大小
rect = { 0, 0, FACTORY_WIDTH * 2 - 1, FACTORY_HEIGHT - 1 };
SetConsoleWindowInfo(hOutput, true, &rect);
//设置窗口样式
SetConsoleTextAttribute(hOutput, SNAKE_BODY_COLOR);
CONSOLE_CURSOR_INFO cursorInfo = { 1, false };
SetConsoleCursorInfo(hOutput, &cursorInfo);
//规则介绍
cout << "使用W、S、A、D控制方向，吃到绿色礼包长度增加，吃到黄色礼包时长度减短，"\
"吃到红色礼包直接死亡。您也可以按CTRL + C退出游戏。按任意键开始游戏。" << endl;
system("pause");
//开始游戏
while (true) {
init();
gameLoop();
system("cls");
SetConsoleCursorPosition(hOutput, { 0, 0 });
printf("You has dead! Retry? (y/n)");
char cmd;
cin >> cmd;
if (cmd != 'y')
break;
else
dead = false;
}
}
逆波兰表达式的C++实现。算术表达式求值，支持加减乘除和幂运算，支持圆括号改变优先级。
//后缀表达式练习
//2018-09-20
#include <stack>
#include <iostream>
#include <cstdlib>
#include <string>
#include <math.h>
using namespace std;
//定义优先级
enum Priority {
PRI_IGNORE,//无效字符，忽略
PRI_NUMBER,//操作数
PRI_PLUS,//加减
PRI_DIVIDE,//乘除
PRI_POWER,//幂
PRI_LEFT_PAR,//左圆括号
PRI_RIGTHT_PAR,//右圆括号
};
//取操作符优先级
Priority getPriority(char symbol) {
if ((symbol >= '0' && symbol <= '9') || symbol == '.')
return PRI_NUMBER;
else if (symbol == '+' || symbol == '-')
return PRI_PLUS;
else if (symbol == '*' || symbol == '/')
return PRI_DIVIDE;
else if (symbol == '^')
return PRI_POWER;
else if (symbol == '(')
return PRI_LEFT_PAR;
else if (symbol == ')')
return PRI_RIGTHT_PAR;
else
return PRI_IGNORE;
}
//中缀表达式转后缀表达式
string toSufixExpression(string express) {
stack<char> operendStack;//操作符暂存栈
string output;//输出后缀表达式
//上一操作符的优先级，如果当前处理的操作符优先级低于它则前操作符出栈
Priority lastPriority = PRI_NUMBER;
string::iterator iter = express.begin();
for (; iter != express.end(); ++iter) {
Priority priority = getPriority(*iter);
switch (priority) {
case PRI_IGNORE:
default:
continue;
case PRI_NUMBER:
output.push_back(*iter);
break;
case PRI_PLUS:
case PRI_DIVIDE:
case PRI_POWER:
case PRI_LEFT_PAR:
//遇到符号向前追加间隔符
output.push_back(' ');
while (operendStack.size()) {
if (getPriority(operendStack.top()) < priority || operendStack.top() == '(')
break;
output.push_back(operendStack.top());
operendStack.pop();
}
lastPriority = priority;
operendStack.push(*iter);
break;
case PRI_RIGTHT_PAR:
while (operendStack.size()) {
if (operendStack.top() != '(') {
output.push_back(operendStack.top());
operendStack.pop();
}
else {
operendStack.pop();
break;
}
}
break;
}
}
//处理完毕，剩余操作符出栈
while (operendStack.size()) {
output.push_back(operendStack.top());
operendStack.pop();
}
return output;
}
//计算后缀表达式
double caculate(string express) {
stack<double> calcStack;//计算存储栈
string::iterator iter = express.begin();
while (iter != express.end()) {
//字符串转整形，并压入栈
if (*iter >= '0' && *iter <= '9') {
string number;
do {
number.push_back(*iter);
++iter;
} while ((*iter >= '0' && *iter <= '9') || *iter == '.');
calcStack.push(atoi(number.c_str()));
continue;
}
//间隔符
if (*iter == ' ') {
++iter;
continue;
}
//操作符，执行运算
if (calcStack.size() < 2)
return 0;
double operandOne = calcStack.top();
calcStack.pop();
double operandTwo = calcStack.top();
calcStack.pop();
switch (*iter++) {
case '+':
calcStack.push(operandTwo + operandOne);
break;
case '-':
calcStack.push(operandTwo - operandOne);
break;
case '*':
calcStack.push(operandTwo * operandOne);
break;
case '/':
calcStack.push(operandTwo / operandOne);
break;
case '^':
calcStack.push(pow(operandTwo, operandOne));
break;
default:
calcStack.push(operandTwo);
calcStack.push(operandOne);
break;
}
}
if (calcStack.size() == 1)
return calcStack.top();
return 0;
}
int main() {
cout << "Please enter an expression:" << endl;
string express;//表达式
getline(cin, express);
if (express.empty()) {
cout << "empty express.\n";
return 0;
}
string output = toSufixExpression(express);
cout << caculate(output) << endl;
system("pause");
return 0;
}
用php写后端动态生成网页内容的时候，用到了DOMDocument类的操作。为了减少创建元素和文本节点的代码(与效率无关)，使用了loadXML()方法载入静态的HTML文本(通过heredoc)。
$xml = new DOMDocument(); $xml->loadXML(<<<_HTML <div class="-article"> <div class="-article-title" onselectstart="return false;"></div> <hr/> <div class="-article-body"></div> <hr/> <div class="-article-extra"></div> <div class="-aborted"></div> <div class="-article-picture"></div> </div> _HTML ); ...... echo xml->saveXML();没错，就是用loadXML()载入HTML，这样做是因为saveHTML()的时候会输出完整的HTML文档(包含html和body元素)而不是我想要的文章部分，而saveXML()则只需要去除首行的文档声明即可。
这里不谈这样的做法好与不好，只说说我遇到的问题。
遇到的问题是，网页版面乱了。出现了块级元素的堆叠，就是生成的元素后面的同级元素变成了它的子元素。感觉是标签没有闭合导致的，用浏览器看了生成的网页代码，终于找到了问题所在。
耗子屎在这一行：
<div class="-aborted"></div>
由于一些原因，生成元素中这块被废弃了，后面的代码又很多地方使用了getElementsByTagName方法获取指定元素，需要靠子元素的位置定位，所以不好直接删除(可见装载静态的html文档结构并不是个好点子)，于是把这个<div>的类名设置为-aborted，然后统一处理。因为是废弃元素，所以自然也不会为它生成内容了，最后saveXML输出的文本中，将这个空元素<div class="-aborted"></div>转化成了<div class="-aborted"/>。在html5中自闭合标签是有严格控制的，只有特定的标签才允许，因此<div/>并没有被浏览器认为是一个闭合的标签，然后和后面的div块混乱了，才导致的这个问题。
解决办法是，给heredoc中的废弃元素的内容加个空格，xml封装器就不会将它当作空元素了。不过最好还是全都动态生成元素，少生幺蛾子。或者使用其他更好的办法。
用PHP写后端，想要达到用户登录后才可以访问一些图片和视频资源的效果，因此要阻止用户直接输入资源地址访问资源。
找了一些资料，自己总结了几种方法。
浏览器在发起HTTP请求时一般都会一同发送Referer头。Referer头是用户跳转前的页面，也就是通过哪个页面发起的请求。通过禁止非法Referer头的资源请求可以一定程度防止资源被非法访问。一般这个都是在web服务器软件上设置而不是后端处理。由于这个方法并不是很靠谱所以没试过（毕竟请求头是由请求方控制的），不过应付一般用户足够了，特别适合用来防止其他网站挂自己服务器的资源链接以转移服务器负载，不过一般小网站用不到就是了。
给资源文件赋以随机的文件名，用数据库记录，然后定期或不定期更新文件名，用户访问页面时后端php动态的查询资源文件名。
这个方法还算可以，缺点是频繁的数据库连接将会增大服务器负载。如果服务器支持可以试试数据库持久连接，不过需要注意持久连接的一些坑，不然可能造成连接锁死之类的问题。
第一种其实意义不大，因为总是要让用户访问的，那只要有授权用户在需要资源文件，你就得把资源放在那里，然后就谁都可以访问了，再然后发现问题回到方法2了——还是得改文件名。
第二种方法是比较靠谱的方法。比如我将资源访问重定向到resource.php这个文件，然后验证身份后根据GET请求参数去找用户请求的文件，然后用readfile函数读取并输出文件就OK。用户的看到的网页源代码将类似这样：
<img src="http://127.0.0.1/resource.php?path=filename"/>
filename可以是真正的资源相对路径，因为用户反正是无法直接访问的，暴露文件路径反而可以省去查数据库的消耗。需要注意的是，如果需要传递的文件路径中包含特殊字符如“/”等需要转义。可在后端统一由某个接口封装，生成安全的资源链接，类似这样：
<?php function getURL($path) { return 'http://127.0.0.1/resource.php?path=' . urlencode($path); } ?> <body> <img src="<?php echo getURL('picture/dog.jpg')?>"> </body>然后resource.php中验证用户是否已授权，如果是且资源访问合法，readfile('/resource_path/' . $_GET['path'])，结束。
这应该是目前最靠谱的办法，不过它也有缺陷。如果请求的资源是视频这种比较大的文件，浏览器会一直等待资源接收完毕才显示后面的内容，而不是页面加载完再以流媒体的方式加载视频资源，因此这个方法无法用于大文件资源。同时，测试发现，css中的url()资源不支持这样的方式，因此背景图片之类的资源也无法使用这种方法。
上面3中已经说了readfile()输出的方法，下面说说硬链接的具体做法。
我们知道，php中有个session的概念，它为一个会话生成一个id，并在客户端以cookie的形式保存，在服务器端创建一个唯一的session文件，用于保存与相关会话相关的数据，每次用户请求中包含的cookie便告诉服务器当前会话的相关数据，比如是否已经登录等。
这里正利用了php的session机制。
我在网站目录中创建了一个temp目录，它包含一个空文件index.html以防止用户直接访问目录看到目录下的文件列表(也可在服务器端配置禁止对目录的访问)，因此用户可以访问该目录下的文件而无法得知它包含哪些子目录或文件，这是前提。
当用户页面需要请求一个需要授权访问的资源时，如果用户是授权的(通过session机制判断)，后端生成相应资源一个非随机的硬链接。它是这样的一个硬链接：
temp/当前会话session ID/例如，如果我的资源目录(禁止用户访问)是/resource_path，存在资源/resource_path/video/dog.mp4。网站目录是/（对于用户），包含temp子目录。那么我的页面应该这样写：
之前的getURL函数变成这样：
function getURL($path, $flow = false) {
//非法资源
if(!file_exists('/resource_path/' . $path)) {
return '';
}
//小文件资源，采用资源重定向方案
if(!$flow) {
return '/resource.php?path=' . urlencode($path);
}
//获取后缀
preg_match('/\.[^\.\/]*$/', $path, $sufix);
$filename = '/temp/'. session_id() . '/' . md5($path) . $sufix[0];
//判断资源链接是否已创建，WWW_ROOT为网站根目录实际路径
if(file_exists(WWW_ROOT . $filename)) {
return $filename;
}
//创建temp/sessionID目录
else if(!file_exists(dirname(WWW_ROOT . $filename))) {
mkdir(dirname(WWW_ROOT . $filename));
}
//创建硬链接。注意Windows不支持PHP的link函数，看你服务器平台
if(stripos(PHP_OS, 'WIN') === false) {
link(HEVER_ROOT . $path, HEVER_ROOT . $filename);
}
else {
system('mklink /H "' . HEVER_ROOT . $filename . '" "' . HEVER_ROOT . $path . '"');
}
return HEVER_HOME . $filename;
}
当然，md5()的参数也可以另外的算，不一定是相对路径。
这样做的好处是，当用户再次请求相同的资源时，只需确保相应的硬链接存在即可直接不管了，因此需要这个硬链接的文件名是非随机的避免查询数据库。而且这样多了一层session id阻隔，即使非法用户知道了生成资源链接文件名的规则也无法访问到资源，因为资源链接是在当前会话的session id目录下的，除非他能猜到某个会话的session id再模拟发送cookie——还不如让他猜用户名和密码呢。
当然这个方法也不是完美的，由于可能会生成大量的硬链接和session文件并且废弃后不会消失，需要定期执行清理脚本来清除过期的链接和文件。我的解决方案是，当用户登录或登出时触发一个脚本，它会清除超过1天未访问过的session文件和对应的temp目录中的同名名录(其实不是同名，session文件还有sess_前缀)。这个灵感来自于wordpress的伪cron机制。
需要注意的是，Windows系统不支持php的link函数，因此得用windows的shell。还有一点，清理php session文件时，如果php.ini中未配置session.save_path，在php中用session_save_path()可能获取不到php默认的session文件存放目录，因此建议在文件首主动配置session目录，使用session_save_path(string $path)函数。
注：以上方案均未经过严密的测试，请谨慎参考。