一些C++笔记

typedef struct tagPROCESSENTRY32
{
    DWORD dwSize; //结构大小
    DWORD cntUsage; //引用计数，已弃用
    DWORD th32ProcessID;  //pid
    ULONG_PTR th32DefaultHeapID;  //默认进程堆，已弃用
    DWORD th32ModuleID; //进程模块，已弃用
    DWORD cntThreads; //此进程开启的进程计数器
    DWORD th32ParentProcessID;  //父进程pid
    LONG pcPriClassBase;  //线程优先级
    DWORD dwFlags;  //已弃用
    TCHAR szExeFile[MAX_PATH];  //进程全名(\*.exe)
} PROCESSENTRY32, *PPROCESSENTRY32;

bool hasProcessRunning(string exename)
{
  map<string, int> processMap;
  PROCESSENTRY32 pe32;
  pe32.dwSize = sizeof(pe32);

  HANDLE processSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if (processSnap == INVALID_HANDLE_VALUE)
  {
     cout<<"CreateToolhelp32Snapshot Error!"<<endl;
     return false;
  }
  bool result = Process32First(processSnap, &pe32);
  int num(0);

  while (result)
  {
    string name = pe32.szExeFile;
    int id = pe32.th32ProcessID;

    processMap.insert(pair<string, int>(name, id));
    result = Process32Next(processSnap, &pe32);
  }

  CloseHandle(processSnap);

  map<string, int>::iterator it = processMap.begin();
  for (; it != processMap.end(); ++it)
    if (it->first == exename) return true;

  return false;
}

// CppTest.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <conio.h>

int main()
{
	puts("CppTest.exe is running...");
	puts("press any key to exit...");
	while (true)
	{
		if (_getch())
			break;
	}
	return 0;
}

BOOL CreateProcess
(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATIONlpProcessInformation
);

BOOL processStart(string path)
{
  STARTUPINFO si;
  memset(&si,0,sizeof(STARTUPINFO));
  si.cb=sizeof(STARTUPINFO);
  si.dwFlags=STARTF_USESHOWWINDOW;
  si.wShowWindow=SW_SHOW;
  PROCESS_INFORMATION pi;

  return CreateProcess(TEXT(path),
                      NULL,
                      NULL,
                      NULL,
                      FALSE,
                      0,
                      NULL,
                      NULL,
                      &si,
                      &pi
                      );

typedef struct WSAData {
    WORD           wVersion;  //ws2_32.dll 建议我们使用的版本号
    WORD           wHighVersion;  //ws2_32.dll 支持的最高版本号
    //一个以 null 结尾的字符串，用来说明 ws2_32.dll 的实现以及厂商信息
    char           szDescription[WSADESCRIPTION_LEN+1];
    //一个以 null 结尾的字符串，用来说明 ws2_32.dll 的状态以及配置信息
    char           szSystemStatus[WSASYS_STATUS_LEN+1];
    unsigned short iMaxSockets;  //2.0以后不再使用
    unsigned short iMaxUdpDg;  //2.0以后不再使用
    char FAR       *lpVendorInfo;  //2.0以后不再使用
} WSADATA, *LPWSADATA;

//服务端代码
#include <stdio.h>
#include <winsock2.h>
#pragma comment (lib, "ws2_32.lib")  //加载 ws2_32.dll
int main()
{
    //初始化 DLL
    WSADATA wsaData;
    WSAStartup( MAKEWORD(2, 2), &wsaData);
    //创建套接字
    SOCKET servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    //绑定套接字
    sockaddr_in sockAddr;
    memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
    sockAddr.sin_family = PF_INET;  //使用IPv4地址
    sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    sockAddr.sin_port = htons(1234);  //端口
    bind(servSock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));
    //进入监听状态
    listen(servSock, 20);
    //接收客户端请求
    SOCKADDR clntAddr;
    int nSize = sizeof(SOCKADDR);
    SOCKET clntSock = accept(servSock, (SOCKADDR*)&clntAddr, &nSize);
    //向客户端发送数据
    char *str = "Hello World!";
    send(clntSock, str, strlen(str)+sizeof(char), NULL);
    //关闭套接字
    closesocket(clntSock);
    closesocket(servSock);
    //终止 DLL 的使用
    WSACleanup();
    return 0;
}

//客户端代码
#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>
#pragma comment(lib, "ws2_32.lib")  //加载 ws2_32.dll
int main()
{
    //初始化DLL
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);
    //创建套接字
    SOCKET sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    //向服务器发起请求
    sockaddr_in sockAddr;
    memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
    sockAddr.sin_family = PF_INET;
    sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    sockAddr.sin_port = htons(1234);
    connect(sock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));
    //接收服务器传回的数据
    char szBuffer[MAXBYTE] = {0};
    recv(sock, szBuffer, MAXBYTE, NULL);
    //输出接收到的数据
    printf("Message form server: %s\n", szBuffer);
    //关闭套接字
    closesocket(sock);
    //终止使用 DLL
    WSACleanup();
    system("pause");
    return 0;
}

template <class T, class Alloc = alloc>
class vector
{
public:
    typedef T value_type;
    typedef value_type* iterator;
    typedef value_type& reference;
    typedef size_t size_type;
protected:
    iterator start;
    iterator finish;
    iterator end_of_storage;
public:
    iterator begin() { return start; }
    iterator end() { return finish; }
    size_type size() const { return size_type(end()-begin()); }
    size_type capacity() const
    { return size_type(end_of_storage-begin()); }
    bool empty() const { return begin() == end(); }
    reference operator[] (size_type n)
    { return *(begin()+n); }
    reference front() { return *begin(); }
    reference back() { return *(end()-1); }
};

#ifndef __HEADERNAME__
#define __HEADERNAME__
...
#endif

//用于修饰返回值的时候
//如果返回值为指针形式，该返回值（指针）不可被修改，且只能赋值给const修饰的同类型指针
//返回值为值类型，加const修饰没有任何价值，因为值类型传递返回的时候会返回一个副本
const char* fun() { return value; }

//以下语句非法
char* str = fun();
//以下语句合法
const char* str = fun();

//不会改变其返回值的时候加上const
//类比于c#中的get属性
string fun() const { return value; }

//参数值不可在函数体中被修改
string fun(const string v) { value = v; return value; }

//左定值，const出现在*左边，指向的值不可改变
const int *p = 8;
//右定向，const出现在*右边
//其指向的地址不可更改，但地址内值可以更改
int num = 8;
int* const p = #
//指向的地址与值不可更改
int a = 8;
const int* const p = &a;

class person
{
private:
    string name;
public:
    //友元函数
    friend void print_name(const person& p);
    //友元类
    friend class dog;
}

void print_name(const person& p)
{ out << "name:" << p.name; }

//以下代码非法
ostream operator << const (ostream& os, const person& p) { return os << p.name; }
//以下代码合法
ostream& operator << (ostream& os, const person& p) { return os << p.name; }

//Big three
class person
{
public:
{
    //one
    person(const char* name);
    //one - 拷贝构造
    person(const person& other);
    //two - 拷贝赋值
    person& operator=(const person& other);
    //three - 析构
    ~person();
private:
    char* name;
};

inline person& person::operator=(const person& other)
{
    //检测自我赋值（self assignment）
    if (this == &other)
        return *this;
    
    //先清理原先内存
    delete[] name;
    //申请新内存
    name = new char[strlen(other.name)];
    //深拷贝
    strcpy(name, other.name);
    return *this;
    
}

person *stu = new person("Zhang san");

//编译器优化代码如下：
void* mem = operator new (sizeof(person));  //分配内存
stu = static_cast<person*>(mem);            //类型转化
stu->person::person("Zhang san");           //调用构造函数

delete stu;

//编译器优化代码如下：
person::~person(stu);   //调用析构函数
operator delete(stu);   //释放内存

#define __STL_TEMPLATE_NULL template<>

//泛化
template <class Key>
struct hash { }; 
//特化 (全特化)
__STL_TEMPLATE_NULL struct hash<char>
{ size_t operator()(char x) const { return x; } };

//泛化
template <class T, class Alloc = alloc>
class vector
{
    ...
};
//偏特化
template <class Alloc>
class vector<bool, Alloc>
{
    ...
};

//泛化
template <class Iterator>
struct iterator_traits
{
    ...
};
//偏特化（指针）
template <class T>
class iterator_traites<T*>
{
    ...
};

class shape
{
public:
    //纯虚函数
    virtual void draw() const = 0;
    //虚函数
    virtual void error(const std::string& msg);
    //非虚函数
    int object_id() const;
    ...
}

//重载++时，带参数的为i++，不带参数的为++i，但是该参数并无作用，仅仅用于区分
//STL中list_iterator源码
template <class T, class Ref, class Ptr>
struct __list_iterator
{
    typedef __list_iterator<T, Ref, Ptr> self;
    typedef bidirection_iterator_tag iterator_category;
    typedef T value_type;
    typedef Ptr pointer;
    typedef Ref reference;
    typedef __list_node<T>* link_type;
    typedef ptrdiff_t difference_type;

    link_type node;

    reference operator*() const { return (*node).data; }
    pointer operator->() const { return &(operator*()); }
    //++iter
    self& operator++()
    {
        node = (link_type)((*node).next);
        return *this;
    }
    //iter++
    self operator(int)
    {
        //此处不会调用重载的*操作
        //因为先遇到了=操作符，会调用copy ctor用于创建tmp并且以*this为初值
        //故*this将被解释为ctor的参数
        //copy ctor:
        //__list_iterator(const interator& x) : node(x.node) { }
        self tmp = *this;
        ++*this;
        return tmp;
    }
    ...
};

list<int> c;
auto iter = c.begin();
++++iter; //合法
iter++++; //非法

//常量转化为非常量
//一般用于修改指针
int array[4] = { 1, 2, 3, 4 };
const int *const_ptr = array;
int *ptr = const_cast<int*>(const_ptr);

const_ptr[1] = 100; //error
ptr[1] = 100;  //pass

//与c中的强制转换基本一致，不对类型进行检查，转换存在安全隐患
//一般用于基类和派生类的转换、基础类型之间的转换
//static_cast不能转换掉原有的const、volatile之类的属性
//c++中的隐式转换就是通过static_cast实现的
float pi = 3.14159f;
int pi_int = static_cast<int>(pi);  //pi_int = 3;

class base {};
class sub : public base {};

base b;
sub s;
base *b_ptr = static_cast<base*>(s);  //pass & safe
sub *s_ptr = static_cast<sub*>(b);  //pass & unsafe

//强制类型转换的手段
//在运行时进行类型检查，不能用于基础类型转换
//基类中没有虚函数，使用dynamic_cast编译不过
//在类的转换时，在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的。
//在进行下行转换 时，dynamic_cast具有类型检查的功能，比 static_cast更安全。
//向上转换即为指向子类对象的向下转换，即将父类指针转化子类指针。
//向下转换的成功与否还与将要转换的类型有关，即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同，否则转换失败。
class base
{
public:
    base() {}
    virtual ~base() {}
    void print() { cout<<"base print called"<<endl; }
};

class sub : public base
{
public:
    sub() {}
    ~sub() {}

    void print() { cout<<"sub print called"<<endl; }
}

sub *s = new sub();
s->print(); //output: sub print called

base *b = dynamic_cast<base*>(sub);
if (b != nullptr)
    b->print(); //output: base print called

base *b = new base();
b->print(); //output: base print called
sub *s = dynamic_cast<sub*>(base);  //pass but s == nullptr

//用于处理无参数的情况
void print() { }

template <typename T, typename... Types>
void print(const T& obj, const Types&... args)
{
    cout<<obj<<endl;
    print(args...);
}

//函数声明
void fun(int);
void fun(void*);

//函数调用
fun(0);         //c++11能够正确识别调用函数fun(int)
fun(NULL);      //调用函数fun(int)，因为c++中NULL的定义为 define NULL 0
fun(nullptr);   //调用函数fun(void*)

//c语言中的NULL定义
#define NULL ((void*)0)
//c++中的NULL定义
#define NULL 0
#else
#define NULL ((void *)0)
#endif

int values[] { 1,2,3 };
vector<int> v { 1,2,3,4 };
vector<string> strs { "one", "two", "three" };

//以下两行代码功能相等
complex<double> c { 4.0, 3.0 };
complex<double> c(4.0, 3.0);

void print(std::initalizer_list<int> vals)
{
    for (auto v:vals)
        cout<<v<<" ";
    cout<<endl;
}

//调用方式
print({1,2,3,4,5});

//使用以下语法对容器进行遍历
for (decl : coll)
{
    statement
}

//example
for (int i : {1,2,3,4,5,6}) { }

vector<double> vec;
for (auto elem : vec) { cout<<elem<<endl; }

//对于引用，需要使用&
for (auto& elem : vec) { elem*=3; }

class zoo
{
public:
    zoo(int i, int j) : a(i), b(j) { }
    zoo(const zoo&) = delete;
    zoo(zoo&&) = default;
    
    zoo& operator=(const zoo&) = default;
    zoo& operator=(const zoo&&) = delete;
    
    virtual ~zoo() { }
private:
    int a, b;

}

template <typename T>
using Vec = std::vector<T, MyAlloc<T>>;

//使用Vec代表该模板类型
//使用宏定义和typedef均无法达到相同效果
//但是Vec无法被特化和偏特化
Vec<int> vec;

//以下代码等同
typedef void(*func)(int, int);
using func = void(*)(int, int);

//调用
void swap(int a, int b) { a^=b^=a^=b; }
func f = swap;

template<typename T>
struct container
{
    //以下代码等同
    typedef T value_type;
    using value_type = T;
}

//无返回值无参数的lambda
[] { std::cout<<"easy lambda"<<endl; }
//直接调用
[] { std::cout<<"easy lambda"<<endl; }();
//间接调用
auto f = [] { cout<<"easy lambda"<<endl; };
f();

//带外部参数的lambda
int id = 0;
//pass by value
//如果没有mutable，id++操作无法执行（编译器报错increment of read-only variable 'id'）
auto f = [id]() mutable
{
    cout<<"id:"<<id<<endl;
    id++;
};