18年7月5日

1、linux下查看可执行文件大小的命令

 ls -lh 文件名
 du -h 文件名

需要记下的一个数据，可以后面用到

435M ScenesServer
254M SessionServer

2、继承的优缺点

优点
1、新的实现很容易，因为大部分是继承而来的 
2、很容易修改和扩展已有的实现 
缺点
1、打破了封装，因为基类向子类暴露了实现细节，高耦合。 
2、白盒重用，因为基类的内部细节通常对子类是可见的 
3、当父类的实现改变时可能要相应的对子类做出改变 
4、不能在运行时改变由父类继承来的实现

何时考虑使用继承：
1、子类是一种特殊的类型，与父类是"is a"的关系，而不只是父类的一个角色。
2、子类的实例不需要变成另一个类的对象。
3、子类扩展，而不是覆盖或者使父类的功能失效

3、继承与组合的区别

优点：
1、不破坏封装，整体类与局部类之间松耦合，彼此相对独立。
2、当前对象只能通过所包含的那个对象去调用其方法，所以所包含的对象的内部细节对当前对象时不可见的
3、当前对象可以在运行时动态的绑定所包含的对象。可以通过set方法给所包含对象赋值

4、shared_ptr的实现和优缺点

//优点就不细说了，主要是不用手动释放内存，方便使用
//缺点，1、性能，使用了计数器，2、存在循环引用的问题，3、类型转换麻烦

//循环引用问题
class B;
class A
{
public:// 为了省去一些步骤这里 数据成员也声明为public
    shared_ptr<B> pb;
    void doSomthing()
    {
    }

    ~A()
    {
        cout << "kill A\n";
    }
};

class B
{
public:
    shared_ptr<A> pa;
    ~B()
    {
        cout <<"kill B\n";
    }
};

int main(int argc, char** argv)
{
    shared_ptr<A> sa(new A()); //
    cout << "sa.use_count():" << sa.use_count() << endl;
    shared_ptr<B> sb(new B());
    cout << "sb.use_count():" << sb.use_count() << endl;
    if(sa && sb)
    {
        sa->pb=sb;
        sb->pa=sa;
    }
    cout<<"sa use count:"<<sa.use_count()<<endl;
    cout<<"sb use count:"<<sb.use_count()<<endl;
    return 0;
}

所以在使用基于引用计数的智能指针时，要特别小心循环引用带来的内存泄漏，循环引用不只是两方的情况，只要引用链成环都会出现问题。当然循环引用本身就说明设计上可能存在一些问题，如果特殊原因不得不使用循环引用，那可以让引用链上的一方持用普通指针（或弱智能指针weak_ptr）即可。
其实在项目的代码中有一例子，GateUser跟GatewayTask关联了，就是连接socket在被放入zOkay线程之前，会实例化GateUser，并且会互相指向对方成员中指针，如果使用shared_ptr就有问题了

void GatewayTask::addToContainer()
{
    pUser = new GateUser(this->accid, this);
    //GateUser下面是有个GatewayTask *gatewayTask;
    //GatewayTask下面有个GateUser *pUser;
    //全部省略
}   

5、设计模式举一例

6、快排
快排是一种交换排序，思想是，对一个序列arr，首先是要确定一个枢轴，首先随机的认为arr[pivotkey] = arr[0]，一趟排序是附设两个指针low和high，它们的大小分别为0和arr.size() - 1,首先从high所指的位置开始查找第一个小于pivotkey位置的元素，并且和prvotkey交换，然后low向前查找第一个大于arr[pivotkey]，并且交换，重复直到low == high位置，算法如下：

//确定枢轴
int Partition(std::vector<int> &arr, int low, int high)
{
    if(arr.empty())
        return 0;
    int pivotkey = 0;
    while(low <= high)
    {
        while(low < high && arr[high] >= arr[pivotkey])
            --high;
        arr[low] = arr[high];
        while(low < high && arr[low] <= arr[pivotkey])
            ++low;
        arr[high] = arr[low]; 
    }
    arr[low] = arr[pivotkey];
    return low;
}

//快速排序
void QuickSort(std::vector<int> &arr, int low, int high)
{
    if(arr.empty())
        return;
    int pivotkey = 0;
    while(low < high)
    {
        pivotkey = Partition(arr, low, high)
        QuickSort(arr, low, pivotkey - 1);
        QuickSort(arr, pivotkey + 1, high);
    }
}