栈也是一种线性结构，如果用一句话介绍栈的话，那就是后进先出（LIFO:Last In First Out）。栈的特性是由于其特殊的存取方式决定的，那就是只能在一端进行存取动作。可以存取的一端一般称为栈顶，另一端称为栈底。究竟栈底索引置为-1还是置为0也是一个讲究，普遍的方法是置为-1，这一点在后面的存取操作中会发现优势。 一般有push和pop操作，以及栈空，栈满等判断。

本文介绍的是基于顺序存储结构的实现，那就是用到了数组，为了更灵活采取的是动态开辟内存空间的形式。栈结构中还有一个top这个俗称栈指针的东西很重要。其实就是一个整型下标索引值。

//在进栈和出栈时 先判断条件是否成立 重中之重
#pragma once
#include<iostream>
using namespace std;
template<class T>
class Stack
{
public:
	int MAXSIZE;//栈最大体积
	T *arr;//动态空间
	int top;//类似于指向当前元素的栈指针
public:
	Stack(const int stacksize = 100);//构造函数
	Stack(const Stack<T>& S);//深复制
	~Stack();//析构函数
	void DestroyStack();//销毁栈
    void output();//输出栈元素 一次性全部输出栈元素
	T pop();//出栈
	void push(T pushelem);//进栈
	bool isEmpty();//判栈满
	bool isFull();//判栈空
	int GetSize();//返回栈元素数
	int Gettop();
};
template<class T>
int Stack<T>::Gettop()
{
	return top;
}
template<class T>
Stack<T>::Stack(const int stacksize)
{
	if(stacksize < 0)//初始化参数 判断
	{
		cout<<"非法值"<<endl;
		exit(1);
	}
	MAXSIZE = stacksize;
	arr = new T[MAXSIZE];
	top = -1 ;//指针 初始化为-1，此时无元素
}
//深复制函数
template<class T>
Stack<T>::Stack(const Stack<T>& S)
{
	MAXSIZE = S.MAXSIZE;
	arr = new T[MAXSIZE];
	if(arr == NULL)
	{
		cout<<"内存分配错误"<<endl;
		exit(1);
	}
	int current = S.top ;//不用top指针操作，防止篡改了top值
	while(current != -1)//复制 直到栈指针指向栈底后一位,跳出循环
	{
		arr[current] = S.arr[current] ;
		current-- ;
	}
	top = S.top ;//把top值赋给当前栈
}

template<class T>
Stack<T>::~Stack()
{
	delete []arr ;//连续空间的删除
}
template<class T>
void Stack<T>::DestroyStack()
{
	delete []arr ;//类似于析构函数的作用,在过程中使用
}
//返回栈最大体积
template<class T>
int Stack<T>::GetSize()
{
	return MAXSIZE ;
}
//判栈满
template<class T>
bool Stack<T>::isFull()
{
	return ((top == MAXSIZE-1) ? true : false);
}
//判栈空
template<class T>
bool Stack<T>::isEmpty()
{
	return (( top == -1) ? true : false);
}
//输入
/*template<class T>
void Stack<T>::input()
{
}*/

//输出
template<class T>
void Stack<T>::output()
{
	int current = top;//只能从栈顶以此输出
	while(current != -1)
	{
		cout<<arr[current]<<endl;
		current--;
	}
}
//压栈
template<class T>
void Stack<T>::push(T pushelem)
{
	if(top == MAXSIZE-1)//栈满,无法压栈操作
	{
		cout<<"Stack is full！"<<endl;
	    return ;
	}
	arr[++top] = pushelem ;
}
//出栈
template<class T>
T Stack<T>::pop()
{
	if(top == -1)//空栈,无法执行出栈操作
	{
		cout<<"Stack is empty!"<<endl;
		exit(1);
	}
	return arr[top--];//只在栈顶的操作,方便快捷,修改top值即可
}

前一篇非常简单，容易懂。不过用在C++中还是需要封装成可以多个项目中使用的代码。

下面将全局变量取消，创建了一个Server类，提供了run函数，同时Server对象还监听信号量，从而优雅的退出。

#include <cstdlib>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <iostream>

using namespace boost;
using namespace boost::asio;

using namespace std;




class Server {
    
public:
    Server(io_service & s)
    : io_(s), signals_(s) {
            signals_.add(SIGINT);
            signals_.add(SIGTERM);
#if defined(SIGQUIT)
            signals_.add(SIGQUIT);
#endif
            signals_.async_wait(boost::bind(&Server::stop, this));
    }
    
    void run() {
        io_.run();
    }
    
private:
    void stop() {
        cout << "x" << endl;
        io_.stop();
    }
    
private:
    io_service& io_;
    boost::asio::signal_set signals_;
};


int main(int argc, char** argv) {
    io_service s;
    Server server(s);
    s.run();
    return 0;
}

       昨天逛YouTube看了几个视频，是用flash的形式介绍网络传输的一些支持，个人觉得这样比较好理解抽象的概念。今天把它们上传到youku，贴出来给大家学习一下。鉴于CSDN不支持嵌入视频，就给出网址吧

http://v.youku.com/v_show/id_XNTAxMjk4OTk2.html

http://v.youku.com/v_show/id_XNTAxMzA2Njcy.html