【C++ Server】八、实战

八、实战
1、关于文件读写和静态变量析构的问题：
#include <QCoreApplication>
#include <QDebug>
#include <QFile>

class Log
{
public:
    Log(int id, const QString& filename)
    {
        m_id = id;
        f.setFileName(filename);
        f.open(QIODevice::WriteOnly|QIODevice::Append);

        qDebug() << m_id << " create";
    }

    ~Log()
    {
        f.close();
        qDebug() << m_id << " delete";
    }

    void log(const QString& info)
    {
        qDebug() << m_id << "write log: " <<info;   // 会打印hello和world.
        f.write(info.toLocal8Bit());
        f.flush();  // 如果不主动调用flush(最后析构的时候会被动调用)，最后log.log的内容只有hello。如果用fstream的方式且调用flush，是只有world。
    }

private:
    int m_id;
    QFile f;
};

void test1()
{
    static Log log(1, "./log.log");     // Log应该用单例模式，这样调用是不合理的.
    log.log("hello");
}

void test2()
{
    static Log log(2, "./log.log");
    log.log("world");
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    {
        test1();
        test2();
    }

    return a.exec();
}

2、int型转string：std::to_string(i);

3、要尽量缩小锁的范围。

4、如果一个类有虚函数，它的大小至少就是1个虚指针的大小。

如果一个类是基类，那么它的析构函数要主动修饰为virtual，否则在多态的使用中不会调用子类的析构函数。

// 删除所有特定值
template<typename T>
void removeAllSameValue(std::vector<T>& group, T value) {
    // remove是把区间内的value元素放在group的后面，然后返回该位置，然后再调用erase删掉该位置(区间)的元素。
    group.erase(std::remove(group.begin(), group.end(), value), group.end());
}

迭代器不要用小于号<进行比较，应该用不等于号!=进行比较。

5、boost里面的网络库asio是用于网络和底层io编程的跨平台C++库，异步模型。支持同步模式和异步模式。

6、基于事件驱动的编程模型。
Reactor模型：lighttpd、libevent、libev、poco
Proactor模式：asio、iocp

7、Ubuntu安装boost和编译使用boost的cpp：
sudo apt-get install libboost-all-dev
g++ -std=c++11 -o test01 test01.cpp -lboost_system

8、c++14才支持lambda形参中使用auto。

9、lambda实际上是编译器给我们生成了一个类，里面重载了()运算符。
[]里面的东西其实相当于类的成员，()里面的东西其实相当于()运算符的形参。

auto lambda1 = [](){};
auto lambda2 = [](int a){ std::cout << a << std::endl; };
int b = 1;
auto lambda3 = [b](int a){ std::cout << a << b << std::endl; };

int c = 1;
auto lambda4 = [b, &c](int a){ std::cout << a << b << c << std::endl; };
sizeof(lambda1);    // 大小是1
sizeof(lambda2);    // 大小是1
sizeof(lambda3);    // 大小是4，因为b是成员变量
sizeof(lambda4);    // 大小是16，因为b是成员变量(占4字节)、c是引用(相当于指针，64位平台是8字节)。字节对齐之后，就变16字节了。

10、boost绑定回调函数，使用bind的方式：
timer1.async_wait(boost::bind(&MyClass::func, this));

11、多线程环境下通过使用boost::asio::io_service::strand的wrap函数包裹lambda表达式来同步回调函数。
io_service相当于是程序和操作系统之间桥梁。

12、#include <time.h>和#include <ctime>的区别在于ctime里面的东西是包含在std命名空间里面的。

13、传this的智能指针给lambda的方式。
auto self = shared_from_this();
func([self = std::move(self)]() { self->funcImp(); } );

14、方式二会更高效，但是当MyClass的构造函数private的时候，无法使用这个方式，因为make_shared里面会调用MyClass的构造函数。
方式一：std::shared_ptr<MyClass>(new MyClass(aaa));
方式二：std::make_shared<MyClass>(aaa);

15、继承enable_shared_from_this的类，在构造函数和析构函数中不能调用shared_from_this函数。

16、<<和write的区别在于<<有很多格式化的操作。
char reply[1024];
std::cout << reply;
std::cout.write(reply, 1024);

17、类的外部如果要使用类内部的常量的时候，应该使用枚举，不应该使用static常量。
一些阿拉伯数字有时候最好也是用枚举来表示，不要直接使用阿拉伯数字。

18、如果io_service运行在独立的线程中，可以通过io_service的post函数将主线程要做的一些事情注册到io_service中，然后这些事情将会在某个时刻运行在io_service所在的线程中。

19、getline函数在linux下按ctrl+d结束输入。
ctrl+c是终止程序。

20、在头文件定义一个函数时(这个头文件没有class)，要把这个函数修饰为inline。否则当有两个cpp包含这个头文件的时候，会生成两份函数实体，链接的时候就会报错。

21、消息协议Protocal Buffer的用法。

编写自己的Protocal.proto，内容如下：
syntax = 'proto3';
message MyName
{
    string name = 1;    // 1表示占位符,第一位.
}
message MyInfo
{
    string name = 1;    // 第一部分是name
    string info = 2;    // 第二部分是info
}

然后用工具protoc将这个Protocal.proto生成对应语言的文件(相当于代码)：
protoc --version
protoc --help
protoc --cpp_out=. Protocal.proto
然后会在当前目录.下面生成Protocal.pb.h和Protocal.pb.cc

然后我们的代码包含Protocal.pb.h即可使用。

在main函数的开始，加上下面这句话，避免版本不兼容：
GOOGLE_PROTOBUF_VERIFY_VERSION;

在main函数的最后，加上下面这句话，避免有工具误判程序内存泄漏：
google::protobuf::ShutdownProtobufLibrary();

编译时，要链接相关静态库：-lprotobuf

std::string newName = "xxxx";
MyName myName;
myName.set_name(newName);
std::string sendBuffer;
auto ok = myName.SerializeToString(&outBuffer);

std::string recvBuffer = "xxxx";
MyInfo myInfo;
auto ok = myInfo.ParseFromString(recvBuffer);
auto nameTmp = myInfo.name();
auto infoTmp = myInfo.info();

Json解析比Protocal Buffer解析慢一点。

22、rand()函数产生的随机数每次启动都是一样的。
for(int i=0; i<10; ++i)
{
    qDebug() << rand()%10+1;    // 本机每次运行的结果都是 2 8 5 1 10 5 0 0 3 5
}

23、安装Linux下的debug调试工具gdb，就相当于程序运行在gdb这个壳里面：
sudo apt-get install gdb
gdb --version
gdb ./mytcpserver
r 9999                    // r是run的意思，9999是mytcpserver的端口号
info thread                // 查看出错的线程
bt                        // 把调用的堆栈打印出来
q                        // 退出

g++编译的时候，编译选项加上 -g 把一些debug调试信息在bt打印出来，当用gdb调试的时候更容易定位到错误。

24、stl容器的使用是线程不安全的。

25、多线程环境下通过使用boost::asio::io_service::strand的post函数包裹lambda表达式来异步保护成员变量。用mutex是同步保护成员变量的。

26、使用boost的log库。
g++编译的时候要加上 -DBOOST_LOG_DYN_LINK 和 -lboost_log 和 -lboost_log_setup 和 -lboost_thread

#include <boost/log/core.hpp>
#include <boost/log/trivial.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/utility/setup/file.hpp>

int main()
{
    boost::log::add_file_log("sample.log");    // 设置日志名字
    boost::log::core::get()->set_filter(
        boost::log::trivial::severity >= boost::log::trivial::info);    // 设置日志等级

    BOOST_LOG_TRIVIAL(trace) << "trace log";
    BOOST_LOG_TRIVIAL(debug) << "debug log";
    BOOST_LOG_TRIVIAL(info) << "info log";
    BOOST_LOG_TRIVIAL(warning) << "warning log";
    BOOST_LOG_TRIVIAL(error) << "error log";
    BOOST_LOG_TRIVIAL(fatal) << "fatal log";
}

27、async的用法：
g++编译选项要加 -pthread
#include <future>
#include <numeric>
// async(func, param...);
// async(flag, func, param...)

28、ctrl+c相当于给程序发一个中断信号INT
相当于 kill -s INT 1589
1589是PID.

在程序中可以捕获并处理这个信号
#include <signal.h>

static std::function<void()> safeQuit;

void signalHander(int sig)
{
    BOOST_LOG_TRIVIAL(info) << "handle signal " << sig;
    if(safeQuit)
    {
        safeQuit();
        safeQuit = nullptr;    // 避免连续的ctrl+c,程序退出多次
    }
}

int main()
{
    boost::asio::io_service io_service;
    safeQuit = [&io_service]{ io_service.stop(); };
    
    signal(SIGINT, signalHander);
}

29、cmake的使用。
主要是维护和编写CMakeLists.txt
cmake会生成一些临时文件，最好放在build目录下。
mkdir build
cd build
cmake ..
然后会生成Makefile，接着直接make即可。