windows中常用类型：

DWORD WINAPI Func1(LPVOID param)
{
cout << "test" << endl;
MessageBox(NULL, "test", "ddd", MB_OK);

return 0;
}

int main()
{
HANDLE p;
DWORD a = 10;
DWORD id = 0;

p = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Func1, &a, 0, &id);
//WaitForSingleObject(p, INFINITE);

return 0;
}

后来查明具体原因为：主线程运行太快，导致程序在Func1线程打印语句之前就已经退出了。更正方法为在main中创建线程Func1后添加同步机制WaitForSingleObject(p, INFINITE)。

#include <iostream>

using namespace std;

int main()
{
      string str("fdsfsdaf");

      cout << str.c_str();     //str.c_str()可以运行
      //cout << str;               //str无法运行

      return 0;
}

不包含string头文件时，cout<<str无法运行；当重新包含string头文件后，cout<<str运行成功。为什么？？？
初步设想：iostream头文件间接导入了string头文件，但是相当一部分的string操作定义在string头文件中，例如程序中的<<操作符重载，不包含string头文件的话无法使用。所以建议编程时还是主动导入string头文件。

2.string类型声明：
string s;
string s(args);
其中args具体参数如下：
str
str, len
chars
chars, len
chars, index, len
n, c
b, e

注意：对string的操作，既可以用迭代器，也可以用下标，它比容器具有更多的灵活性。以下使用b、e和p表示迭代器，pos表示下标，cp表示指向c类字符串的指针。

3.string操作：
=、assign()：
对string对象赋以新值。=右边可以是string类型、c_string类型甚至是'a'这样的单一字符。使用assign()可以更灵活的对string进行赋值，例如：
args具体参数如下：
str
str, len
chars
chars, len
chars, index, len
n, c
b, e

swap()：
交换两个字符串的内容，例如s1.swap(s2)，注意里面不可以是c_string类型。

+=、append(args)、push_back()：
在尾部添加字符。+=后面可以是string、c_string甚至是'a'这样的单一字符。其中args具体参数如下：
str
str, len
chars
chars, len
chars, index, len
n, c
b, e
s.push_back('x')                    //用于每次增加一个字符。

insert()：
在string某个位置插入字符，插入位置在给定的索引处。例如s.insert(4, str)。注意，这种形式的insert()函数不支持传入单个字符，要想传入单个字符必须写成字符串的形式。
s.insert(p, t)              //在p前插入元素t
s.insert(p, n, t)          //在p前插入n个t
s.insert(p, b, e)         //b和e是迭代器
s.insert(pos, args)
其中args具体参数如下：
str
str, len
chars
chars, len
chars, index, len
n, c
b, e

erase()：删除字符。
s.erase(p)                //删除p指向的元素，返回指向该元素后面元素的迭代器
s.erase(b, e)            //删除b和e间的元素，返回指向该元素后面元素的迭代器
s.erase(pos, len)      //删除pos下标开始的len个字符

clear()：
清空字符，例如s.clear()，效果等同于s=""，但是内部机制是否一样未知。

replace()：替换字符。
s.replace(pos, args)
其中args具体参数如下：
str
str, len
chars
chars, len
chars, index, len
n, c
b, e
同理把前两个参数换成b和e也可以。

+：
串联字符串。

==、!=、<、<=、>、>=、compare()：
比较字符串，可以在string与string、string与c_string间进行比较，例如str1 < str2，s <= "abc"。compare()函数支持多参数处理，支持用索引值和长度定位子串来进行比较，返回0表示相等，正数表示大于，负数表示小于，例如：
s.compare("abcd")
s.compare(s2)
s.compare(pos, len, s2)
s.compare(pos1, len1, s2, pos2, len2)
s.compare(pos, len, "....")
s.compare(pos1, len2, "....", pos2, len2)

size()、length()：
返回字符数量，两者等效。
empty()：
判断字符串是否为空。
max_size()：
返回字符的可能最大个数，很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。
capacity()：
返回重新分配前的字符容量。
reserve()：
重置字符容量。

[]、at()：
存取单一字符，不同点在于at()会检查索引是否有效，即是否超出0～s.length()-1的范围，如果超出会抛出out_of_range的异常。

>>、getline()：
从stream中读取某值，其中getline()是读取一行，直到遇到分行符或者文件结尾符。
<<：
将某值写入stream。

copy()：
将某string写入一个既有的c_string中，例如s.copy(chars, s.size())，得到的字符串不以"\0"结尾，需要注意这点。
c_str()：
函数原型是const char* c_str() const{}，例如s.c_str()将返回一个const char*类型，且以"\0"结尾。
data()：
函数原型是const char* data() const{}，例如s.data()返回一个const char*类型，与c_str()不同的是它返回的字符串不以"\0"结尾。

substr()：
返回某个子字符串。
s.substr()                 //返回s的全部内容
s.substr(pos)            //从pos下标开始的所有字符
s.substr(pos, len)     //从索引pos开始的len个字符。

begin()、end()：
提供类似STL的迭代器支持。
rbegin()、rend()：
逆向迭代器。
get_allocator()：返回配置器。

查找函数：
find
rfind
find_first_of
find_last_of
find_first_not_of
find_last_not_of
参数1是被搜寻的对象，参数2指出搜寻起点索引（可无），参数3指出搜寻的字符个数（可无），返回值是索引值，类型是string::size_type，如果没有找到目标，返回string::npos。注意：string::npos的类型是string::size_type，并不是int而是unsigned int。
参数如下：
c, pos              //从pos下标开始查找字符c，pos可默认为0
s2, pos            //从pos开始查找string类型s2，pos可默认为0
cp, pos            //从pos开始查找字符串cp，pos可默认为0
cp, pos, len      //查找cp前n个字符，pos和len不可默认

#include <math.h>

int abs(int x);
float fabs(float x);
float sin(float x);
float asin(float x);          //x in [-1.0, 1.0]
float cos(float x);
float acos(float x);         //x in [-1.0, 1.0]
float tan(float x);
float atan(float x);
float atan2(float x, float y);  //求x/y的反正切值
float sinh(float x);                 //求x的双曲正弦值，(e^x – e^(-x)) / 2
float cosh(float x);                //求x的双曲余弦值，(e^x + e^(-x) / 2)
float tanh(float x);                //求x的双曲正切值，(e^x – e^(-x)) / (e^x + e^(-x))
float ceil(float x);
float floor(float x);
float exp(float x);
float fmod(float x, float y);     //求x/y的余数，x – x / y
float frexp(float x, int *exp);  //把x分解成尾数和2的指数，返回数是尾数，exp是指数
float ldexp(float x, int exp);    //转载浮点数，返回x*2^exp的值
float modf(float x, float *i);   //将x分解成整数和小数，返回值是小数部分，i是整数部分
float hypot(float x, float y);  //根据勾股定理返回斜边
float log(float x);                     //x > 0
float log10(float x);                 //x > 0
float pow(float x, float y);     //x > 0
float sqrt(float x);                   //x > 0

字符函数：

#include <ctype.h>

int isalnum(int c);       //判断是否为0-9、a-z、A-z中的字符
int isalpha(int c);
int isaldigit(int c);
int iscntrl(int c);         //判断c是否为控制字符，0X00-0X1F之间或0X7F（DEL）
int islower(int c);
int isupper(int c);
int isascii(int c);         //判断是否为ASCII码，指0X00-0X7F之间的字符
int isgraph(int c);        //c是否为除空格之外的可打印字符，指0X21-0X7E
int isprint(int c);         //c是否为可打印字符，包含空格，指0x20-0x7E
int ispunct(int c);        //c是否为标点符号，指非字符数字，非空格的可打印字符
int isspace(int c);       //空白符指空格、制表符、换页符、回车符、换行符
int isxdigit(int c);        //是否16进制数字，指0-9、A-F、a-f之间的字符
int toascii(int c);         //将c转换成ascii码，即高位清零，仅保留低7位
int tolower(int c);
int toupper(int c);

动态内存分配：

#include <stdlib.h>

void *malloc(unsigned int num_bytes);
void *realloc(void *mem_address, unsigned int newsize);
void *alloc(int num_elems, int elem_size);

字符串函数：

#include <string.h>

void *memchr(void *buf, char ch, unsigned count);
//在buf所指内存前count个字节查找字符ch，返回指向ch的指针或NULL
int memcmp(void *buf1, void *buf2, unsigned int count);
//比较buf1和buf2的前count个字节，< = > 分别返回 <0 =0 >0
int memicmp(void *buf1, void *buf2, unsigned int count);
//比较buf1和buf2的前count个字节，但不区分字母大小写
void *memccpy(void *dest, void *src, unsigned char ch, unsigned int count);
//从src中复制不多于count个字节到dest，遇到字符ch则停止复制。返回指向ch后的第一个字符的指针，没有遇到ch则返回NULL，注意ch也被复制
void *memcpy(void *dest, void *src, unsigned int count);
//从src中复制不多于count个字节到dest，返回指向dest的指针，注意dest和src不能重叠
void *memmove(void *dest, const void *src, unsigned int count);
//从src中复制不多于count个字节到dest，返回指向dest的指针，其中dest和src所指内存区域可以重叠，但是src内容会被更改
void *memeset(void *buffer, int c, int count);
//将buffer所指区域前count个字节设置成c字符，返回buffer指针

   //×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
   //分界线
   //×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

char *strcpy(char *dest, char *src);
// src所有字符串复制到dest中，两者区域不可重叠，且dest必须要有足够空间，返回dest指针
char *strncpy(char *dest, char *src, int n);
// src前n个字符复制到dest中，两者区域不可重叠，且dest必须要有足够空间，返回dest指针。如果src前n个字符不含"\0"，则dest不以"\0"结束；如果src长度小于n，则用"\0"填充dest直到n个字节复制完毕
char *strdup(char *s);
//函数内malloc()分配空间，返回指向被复制的字符串的指针，需要在函数中人工free掉分配的空间

char *strcat(char *dest, char *src);
//联接dest和src，dest改变，两者区域不可重叠，且dest必须要有足够空间，返回dest指针
char *strncat(char *dest, char *src, int c);
//联接dest和src前n个字符，两者区域不可重叠，且dest必须要有足够空间，返回dest指针

int strcmp(char *s1, char *s2);
//比较s1和s2，< = > 分别为 <0 =0 >0
int strncmp(char *s1, char *s2, int n);
//比较s1和s2前n个字符，同上
int stricmp(char *s1, char *s2);
//比较s1和s2，不区分字符大小写
int strnicmp(char *s1, char *s2, int n);
//比较s1和s2前n个字符，不区分字符大小写

   char *strchr(char *s, char c);
//查找s中c的首次出现位置，返回c位置指针或者NULL
int strcspn(char *s1, char *s2);
//在s1中搜索s2中出现的字符，返回第一个出现在s1中的下标值，亦即在s1中出现而s2中没有出现的字符串长度
char *strpbrk(char *s1, char *s2);
//在s1中搜索s2中出现的字符，返回第一个出现在s1中的字符指针或者NULL
   char *strstr(char *haystack, char *needle);
//从haystack中寻找needle第一次出现的位置，返回第一次出现的位置指针或者NULL

int strlen(char *s);
//返回s的长度，不包括结束符NULL
char *strlwr(char *s);
//将s转换为小写字母形式，返回指向s的指针
char *strupr(char *s);
//将s转换为大写字母形式，返回指向s的指针
char *strrev(char *s);
//将s的所有字符顺序颠倒过来，不包括“\0”，返回s指针
char *strset(char *s, char c);
//将s的字符设置成字符c（"\0"不变），返回s的指针

函数原型：void *memcpy(void *dest, const void *source, size_t count);
返回值说明：返回指向dest的void *指针
函数说明：memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。

原型：char *strstr(char *haystack, char *needle);
用法：#include <string.h>
功能：从字符串haystack中寻找needle第一次出现的位置（不比较结束符NULL)。
说明：返回指向第一次出现needle位置的指针，如果没找到则返回NULL。

函数原型：char * strcpy(char * strDest,const char * strSrc);
char * strcpy(char * strDest,const char * strSrc)
{
if ((strDest==NULL)||(strSrc==NULL))
throw "Invalid argument(s)";
char * strDestCopy=strDest;
while ((*strDest++=*strSrc++)!='\0')
;
return strDestCopy;
}

memcpy和memmove 的区别：
函数memcpy()从source指向的区域向dest指向的区域复制count个字符，如果两数组重叠，不定义该函数的行为。而memmove()如果两函数重叠，赋值仍正确进行。memcpy函数假设要复制的内存区域不存在重叠，如果你能确保你进行复制操作的的内存区域没有任何重叠，可以直接用memcpy；如果你不能保证是否有重叠，为了确保复制的正确性，你必须用memmove。memcpy的效率会比memmove高一些，如果还不明白的话可以看一些两者的实现：

void *memmove(void *dest, const void *source, size_t count)
{
assert((NULL != dest) && (NULL != source));
char *tmp, *s;
if (dest <= src)
{
    tmp = (char *) dest;
    s = (char *) src;
    while (count--)
          *tmp++ = *s++;
}
Else
{
    tmp = (char *) dest + count;
    s = (char *) src + count;
    while (count--)
        *--tmp = *--s;
}
return dest;
}

12.++i与i++
int arr[] = {6,7,8,9,10};
int *ptr = arr;
*(ptr++) +=123;
Print(“%d %d”, *ptr, *(++ptr));
一定要注意求值顺序，*(ptr++) +=123中先做加法6+123，然后ptr++，此时指针指向7；对于Print(“%d %d”, *ptr, *(++ptr))，从后往前执行，先做++ptr，指向8，然后输出8和8。
注：一般禁止在语句中这样使用++运算符，因为会依赖不同的编译器而有所不同。例如，TC中printf语句从右向左执行，VC6.0中同样从右向左执行，但是在遇见后增运算符a++或者a--时是在整个printf语句后才执行。
int i=8;
printf("%d\n%d\n%d\n%d\n",++i,--i,i++,i--);
这个函数的输出结果在VC里是8 7 8 8，在TC里是8 7 7 8。
int i=3, j;
j = (i++)*(i++);
这个表达式输出j是9，i最后是5，因为两个i++是在整个运算式之后才进行的。
int i=3, j;
j = (++i)*(++i);
这个表达式输出j是25，i最后是5，因为++i相当于i加1后将i放入式子中，所以j=i*i，且i为5。
int i=3, j;
printf(“%d %d”, ++i, ++i);
这个表达式输出5, 4，为什么两个值不一样呢？因为printf是函数，将++i传给printf后，相当于打印的是形参，而两个++i传入的形参不同。
注：特别要注意宏、运算与函数使用i++和++i的情况，容易让人困惑……

13.
add ( int a, int b )
{
return a + b;
}

int main(int argc, char* argv[])
{
printf ( "2 + 3 = %d", add ( 2, 3) );
return 0;
}
在C语言中，凡不加返回值类型限定的函数，就会被编译器作为返回整型值处理；C++语言有很严格的类型安全检查，不允许上述情况（指函数不加类型声明）发生。可是编译器并不一定这么认定，譬如在Visual C++6.0中上述add函数的编译无错也无警告且运行正确。
#include "stdio.h"
int fun()
{
return 1;
}

main()
{
printf("%d",fun(2));
getchar();
}
在C语言中，可以给无参数的函数传送任意类型的参数，但是在C++编译器中编译同样的代码则会出错。所以，无论在C还是C++中，若函数不接受任何参数，一定要指明参数为void。
按照ANSI(American National Standards Institute)标准，不能对void指针进行算法操作，即下列操作都是不合法的：
void * pvoid;
pvoid++;       //ANSI：错误
pvoid += 1;    //ANSI：错误
ANSI标准之所以这样认定，是因为它坚持：进行算法操作的指针必须是确定知道其指向数据类型大小的。
例如：
int *pint;
pint++;        //ANSI：正确
pint++的结果是使其增大sizeof(int)。
但是大名鼎鼎的GNU(GNU's Not Unix的缩写)则不这么认定，它指定void *的算法操作与char *一致。
因此下列语句在GNU编译器中皆正确：
pvoid++;      //GNU：正确
pvoid += 1;   //GNU：正确
pvoid++的执行结果是其增大了1。
在实际的程序设计中，为迎合ANSI标准，并提高程序的可移植性，我们可以这样编写实现同样功能的代码：
void * pvoid;
char* tmp = (char*)pvoid;
tmp++;    //ANSI：正确；GNU：正确
tmp += 1; //ANSI：正确；GNU：正确
GNU和ANSI还有一些区别，总体而言，GNU较ANSI更“开放”，提供了对更多语法的支持。但是我们在真实设计时，还是应该尽可能地迎合ANSI标准。

#include "stdafx.h"
#include "DLLSample.h"

#pragma comment(lib, "DLLSample.lib")    //你也可以在项目属性中设置库的链接

int main()
{
        TestDLL(123);   //dll中的函数，在DllSample.h中声明
        return(1);
}

（2）显式链接
需要函数指针和WIN32 API函数LoadLibrary、GetProcAddress装载，使用这种载入方法，不需要.lib文件和.h头文件，只需要.dll文件即可（将.dll文件置入工程目录中）。

#include <iostream>
#include <windows.h>         //使用函数和某些特殊变量
typedef void (*DLLFunc)(int);
int main()
{
        DLLFunc dllFunc;
        HINSTANCE hInstLibrary = LoadLibrary("DLLSample.dll");

        if (hInstLibrary == NULL)
        {
          FreeLibrary(hInstLibrary);
        }
        dllFunc = (DLLFunc)GetProcAddress(hInstLibrary, "TestDLL");
        if (dllFunc == NULL)
        {
          FreeLibrary(hInstLibrary);
        }
        dllFunc(123);
        std::cin.get();
        FreeLibrary(hInstLibrary);
        return(1);
}

LoadLibrary函数利用一个名称作为参数，获得DLL的实例（HINSTANCE类型是实例的句柄），通常调用该函数后需要查看一下函数返回是否成功，如果不成功则返回NULL（句柄无效），此时调用函数FreeLibrary释放DLL获得的内存。
GetProcAddress函数利用DLL的句柄和函数的名称作为参数，返回相应的函数指针，同时必须使用强转；判断函数指针是否为NULL，如果是则调用函数FreeLibrary释放DLL获得的内存。此后，可以使用函数指针来调用实际的函数。
最后要记得使用FreeLibrary函数释放内存。

注意：应用程序如何找到DLL文件？
使用LoadLibrary显式链接，那么在函数的参数中可以指定DLL文件的完整路径；如果不指定路径，或者进行隐式链接，Windows将遵循下面的搜索顺序来定位DLL：
（1）包含EXE文件的目录
（2）工程目录
（3）Windows系统目录
（4）Windows目录
（5）列在Path环境变量中的一系列目录

 return a;
}
一般在使用返回值引用时，常返回全局变量等无法析构的变量，例如：
int a = 5;    //a是全局变量
int result;
result = Function();  //不会出现warning
int &Function()
{
 return a;
}
注意int &Function()的返回值可以充当左值，但是如果x是函数的临时变量，对其进行引用是危险的；所以要保证返回值不会因函数返回而被析构。如下：
int x = 0;    //x是全局变量
int &Function()
{
 return x;
}
void main()
{
 Function() = 100;   //此时x等于100
}
（2）指针可以指向NULL，而引用不能引用NULL。
（3）引用一旦声明，引用的对象不能改变（不能引用其他对象了），但是引用对象的值可以改变；指针可以随时改变指向的对象，因此说指针更危险，引用比指针安全。可以说，引用是在不牺牲性能的情况下，更安全的利用指针特性所使用的技术。
（4）理论上存在两种必须用指针的情况，其他情况下建议用引用而不是指针：
A.可能存在不指向任何对象(NULL)时，使用指针。
B.需要指向不同对象时，使用指针。
（5）在函数Function(int* &p)中，使用&目的是为了可以改变p指针本身，使其能指向其他对象，这种用法和Function(int** p)是一样的，即指向指针的指针。

2.const与指针
（1）const int a = 10与int const a = 10等价；同理const int*与int const*是等价的。
（2）const int *a是指向const对象的指针，不可通过指针改变对象值，而int * const a是const指针，指针只能指向该对象。
（3）指针指向const对象的情况
const int a = 40;
int *p;
p = &a;         //错，编译错误，
p = (int*)&a;   //编译通过，但是p无法改变a的值
const int *p;
p = &a;         //ok

3.const与引用
非Const引用只能绑定到与该引用同类型的对象；
Const引用则可绑定到不同但相关类型的对象或绑定到右值。
（1）const对象（包括常量、常量+变量生成的无名临时变量）必须用const引用来引用，而反过来const引用可以引用const和非const变量。
int a = 5;
const int b = 10;
int &ref = a;         //ok
int &ref = b;         //error
const int &ref = b;   //ok，必须为const引用
const int &ref = a;   //ok
const int &ref = 5;      //ok，必须为const引用
const int &ref = a + 3;  //ok，必须为const引用
（2）const引用可以用不同类型的对象初始化，
对于不同类型间的引用：
double a = 3.5;
const int &ref = a;
实际上其工作流程是先定义int tmp = (int)a，然后const int &ref = tmp，所以必须用const引用，否则会导致错误。常量+变量生成的无名临时变量同理。
（3）const引用可以指向需要临时对象的对象或值
const int ival = 1024;
const int* &b = &ival;        //error
const int* const &b = &ival;  //ok
解释是：
typedef const int * P;
P &b = &ival;        //error，因为&ival的值不可改变，而b是非常量指针
P const &b = &ival;  //等价于const P &b = &ival;

大家可以看到，将二维数组当作参数的时候，必须指明所有维数大小或者省略第一维的，但是不能省略第二维或者更高维的大小，这是由编译器原理限制的。大家在学编译原理这么课程的时候知道编译器是这样处理数组的，对于数组：
int p[m][n]，
如果要取p[i][j]的值(i>=0 && i<m && 0<=j && j < n)，编译器是这样寻址的，它的地址为：
p + i*n + j;
从以上可以看出，如果我们省略了第二维或者更高维的大小，编译器将不知道如何正确的寻址。但是我们在编写程序的时候却需要用到各个维数都不固定的二维数组作为参数，这就难办了，编译器不能识别阿，怎么办呢？不要着急，编译器虽然不能识别，但是我们完全可以不把它当作一个二维数组，而是把它当作一个普通的指针，再另外加上两个参数指明各个维数，然后我们为二维数组手工寻址，这样就达到了将二维数组作为函数的参数传递的目的，根据这个思想，我们可以把维数固定的参数变为维数随即的参数，例如：
void Func(int array[3][10]);
void Func(int array[][10]);
变为：
void Func(int **array, int m, int n);
在转变后的函数中，array[i][j]这样的式子是不对的(不信，大家可以试一下)，因为编译器不能正确的为它寻址，所以我们需要模仿编译器的行为把array[i][j]这样的式子手工转变为
*((int*)array + n*i + j);
在调用这样的函数的时候，需要注意一下，如下面的例子：
int a[3][3] =
{
      {1, 1, 1},
      {2, 2, 2},
      {3, 3, 3}
};
Func(a, 3, 3);
根据不同编译器不同的设置，可能出现warning 或者error,可以进行强制转换如下调用：
Func((int**)a, 3, 3);

补充：
对于最后利用指针代替二维数组的做法稍显累赘，只需要一层的指针即可：
int a[3][3] =
{
      {1, 1, 1},
      {2, 2, 2},
      {3, 3, 3}
};
函数使用如下：
Func((int*)a, 3, 3);
函数声明如下：
void Func(int *array, int m, int n);
函数中使用指针如下：
*(array + n*i + j);

hh.a = 0;
hh.b = -1;
cout << hh.a << endl;
最后的结果是hh.a = 255。原因是hh.b = -1时，低位字节存储11111111（补码），那么整个4个字节就是00000000 00000000 00000000 11111111，即255。（正数的原码、反码、补码都一样，负数的原码不变，反码在原码基础上取反，补码在原码基础上取反加1）

int nn[100],n=100;
int com(const void *a,const void *b)
{
    return *(int*)a-*(int*)b;
}    

qsort((void *)nn,n,sizeof(int),com);

注意：缺省是升序排序，可以通过函数com改变排序顺序。

sort()定义在在头文件<algorithm>中。
template<typename _RandomAccessIterator>
void __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
sort函数是标准模板库的函数，已知开始和结束的地址即可进行排序，可以用于比较任何容器（必须满足随机迭代器），任何元素，任何条件，执行速度一般比qsort要快。具体事例如下：

char ch[20]="sdasdacsdasdas";

cout<<ch<<endl;
sort(ch,ch+14);
cout<<ch<<endl;

注意：缺省是升序排序。sort中一个改变排序顺序的例子如下：

#include <iostream>
#include <algorithm>

using namespace std;

bool cmp (const int a, const int b)
{
    return a > b;
}

int main()
{
    int data[5];

    for(int i = 0; i < 5; i++)
        cin >> data[i];

    sort(data, data + 5, cmp);

    return 0;
}

《The C++ Programming Language》/《C++程序设计语言》
最新版本：第三版特别版
简称TC++PL，有其他语言的丰富经验的。（也有人简称之为“TCPL”，但需与另一本《The C Programmer Language》区分开来）

《Essential C++》
《Accelerated C++》
这两本薄一些，都是不错的选择。《Accelerated C++》本人没有读过，从各方面的评价来看，完全值得推荐。

以上几本书都有相应的中文版，而且翻译的质量都不错。上面的书未必都需要读一遍，但无论如何，TC++PL是应该阅读的。

（二）进阶A：
这个路线侧重于语言本身

《Effective C++》
最新版本：第二版（第三版国外已上架，国内一些网上书店也在预订中）
简称EC。C++程序员必读！很多时候，我们说C++圣经不是指TC++PL，而是这一本。《The Pragmatic Programmer》一书中写到：“一旦你发现自己要参与C++项目的开发，赶快跑（不要走）到书店去购买Scott Mayer的《Effective C++》，可能还要《More Effective C++》”。

《C++ Coding Standards: 101 Rules, Guidelines, and Best Practices》/《C++ 编程规范》
个人认为此书应为C++程序员必备的案头书。几乎Effective系列和Exceptional系列都在这里得到了总结。最新的模版、异常的业界经验都在这里的到了体现。可能的唯一缺陷就是对一个新手而言，关于“为什么这么做”的问题，解释的不够。
我的看法是：如果你不理解其中的条款，记忆，并且照做；如果你理解其中的条款，我猜你一定会同意书中的观点。我认为这本书中的内容至少在2009年以前都不会过时，人们将广为传诵它制定的101条戒律。
还不知道他的简称，也许“101”会成为一个候选者？

提到《Effective C++》，那么另外三本书一一浮出水面：
《More Effective C++》
《Exceptional C++》
《More Exceptional C++》。
新书《Exceptional C++ Style》也是值得一看的好书。
上述几本书，一本也不应该放过。
个人建议上述书籍按顺序阅读。并且，在将来反复阅读这几本书。

（三）进阶B：
这个路线侧重于程序库。

《The C++ Standard Library》/《C++标准程序库—自修教程与参考手册》
听说过STL吗？这本书会教你最基本的，也是最重要的STL的使用。这本书，应该是必读的。

《Effective STL》
会使用STL还不够，还必须知道什么时候选择什么STL组件，这是STL使用的必读书。

《Generic Programming and the STL: Using and Extending the C++ Standard Template Library》/《泛型编程与STL》。
这本书理论性较强，但是真的很严谨，而且并不是非常难懂。理解其中对于Concept的解释，将是非常重要的。

《C++ STL》
这不是讲述使用程序库的，而是讲述程序库实现原理的。肠胃不好的，需要慢慢吸收。

这个路线的书，仍然是建议按顺序阅读。
进阶A、进阶B两个路线应该是可以并行的。

其他进阶参考书
提出这些参考书，只是避免争议，也为开阔视野，笔者并不曾完全读过所有的。

《Thinking in C++》/《C++编程思想》
这本书及其中文版传言好坏都有，没有认真看过，不做评价，如果确有兴趣，不妨尝试一下该书。

以下几本书基本上涉及的都是语言本身，大体上可以按照以下的顺序阅读。

《C++必知必会》
如果早一年，这本书将是重量级的，然而它被101和《Exceptional C++ Style》盖过一头。

《C++ Gotchas: Avoiding Common Problems in Coding and Design》/《C++程序设计陷阱》
这又是一本我未曾读过，而且广受好评的书。

《STL 源码剖析》
这本书我刚到手，就被人"借"走，以至于到现在也没有看过。看过这本书的朋友，可以给一个合适的评价。

高级：
《The Design and Evolution of C++》/《C++语方的设计和演化》
简称D&E，内容并不艰深，Bjarne的书，仅此，就值得一读。
前段时间，互动网曾8块一本（人民币）贱卖此书，现在好像没了。

《Inside The C++ Object Model》/《深度探索C++对象模型》
C程序员读后一定会觉得C++原来并不神秘。

《C++ Template》
在阅读STL、Boost或者Loki的源代码之前，请仔细阅读本书，它可以减轻一些阅读的烦恼。这本书是讨论C++模版的权威。

《Modern C++ Design Generic Programming and Design Patterns Applied》/《C++设计新思维——泛型编程与设计模式之应用》
简称MCD。在阅读MCD之前，建议先阅读一下《C++ Template》。

《对象揭秘：Java、Eiffel和C++》
你对C++不满吗？这本书可以部分地帮你完成抱怨的目标。也许它还可以让你不迷信C++。

最后，一份C++标准文档也是应该加以咀嚼的。
还有一些书籍，并不能简单的归于C++，也难以在纯粹的书本学习中加以掌握。《Design Patterns》/《设计模式》一书就归于此类。

所有上述的书籍，要么谈论C++语言本身，要么谈论STL的，要么兼而有之（当然严格讲STL也是C++语言非常重要的一部分）。偶尔，某些书中条目也会涉及实际工程。这些书并不是C++软件开发的全部，但是他们很重要。阅读这些书，未必需要化费太多的精力，有时候是会困难，但也有时候会很快速。
最后，编程语言并非计算机科学技术的全部，尤其对于在校的学生来说，打好基础、开阔视野都是非常重要的。

HANDLE CreateThread(
                                       LPSECURITY_ATTRIBUTES lpThreadAttributes,
                                       DWORD dwStackSize,
                                       LPTHREAD_START_ROUTINE lpStartAddress,
                                       LPVOID lpParameter,
                                       DWORD dwCreationFlags,
                                       LPDWORD lpThreadId
                                       );

其中各参数说明如下：
llpThreadAttributes：指向一个 SECURITY_ATTRIBUTES 结构的指针，该结构决定了线程的安全属性，一般置为 NULL；
ldwStackSize：指定了线程的堆栈深度，一般都设置为0，表示线程堆栈大小与创建它的线程相同；
llpStartAddress：表示新线程开始执行时代码所在函数的地址，即线程的起始地址。一般情况为(LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc 是线程函数名，函数原型如下：
 DWORD  WINAPI  threadfunc(LPVOID  param);
llpParameter：指定了线程执行时传送给线程的32位参数，即线程函数的参数；
ldwCreationFlags：控制线程创建的附加标志，可以取两种值。如果该参数为0，线程在被创建后就会立即开始执行；如果该参数为CREATE_SUSPENDED,则系统产生线程后，该线程处于挂起状态，并不马上执行，直至函数ResumeThread被调用；
llpThreadId：该参数返回所创建线程的ID；

DWORD WINAPI Func1(LPVOID param)
{
    cout << "test" << endl;
    MessageBox(NULL, "test", "title", MB_OK);

    return 0;
}

int main()
{
    HANDLE p;
    DWORD a = 10;
    DWORD id = 0;

    p = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Func1, &a, 0, &id);
    //WaitForSingleObject(p, INFINITE);

    return 0;
}

2.线程悬挂和恢复：创建新的线程后，该线程就开始启动执行。但如果在dwCreationFlags中使用了CREATE_SUSPENDED特性，线程并不马上执行，而是先挂起，等到调用ResumeThread后才开始启动线程。

DWORD SuspendThread(HANDLE hThread);
//该函数用于挂起指定的线程，如果函数执行成功，则线程的执行被终止。
DWORD ResumeThread(HANDLE hThread);
//该函数用于结束线程的挂起状态，执行线程。

3.线程优先级操作：

int GetThreadPriority(HANDLE hThread);
//调用该函数得到线程优先权。
BOOL SetThreadPriority(HANDLE hThread,int nPriority); 
//调用该函数来设置线程的优先权。

4.线程退出：当调用线程的函数返回后，线程自动终止。

//如果需要在线程的执行过程中终止则可调用函数： 
VOID ExitThread(DWORD dwExitCode); 
//如果在线程的外面终止线程，则可调用下面的函数： 
BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode); 

注意：
(1)TerminateThread函数可能会引起系统不稳定，而且线程所占用的资源也不释放。因此，一般情况下，建议不要使用该函数。
(2)如果要终止的线程是进程内的最后一个线程，则线程被终止后相应的进程也应终止。
(3)释放资源后，将线程HANDLE置成NULL。
(4)使用TerminateThread后，需调用CloseHandle( )函数释放线程所占用的堆栈。


MFC下多线程编程之工作线程编程

1.线程创建：

CWinThread*AfxBeginThread( 
                                                AFX_THREADPROC pfnThreadProc, 
                                                LPVOID pParam,
                                                int nPriority = THREAD_PRIORITY_NORMAL,
                                                UINT nStackSize = 0,
                                                DWORD dwCreateFlags = 0, 
                                                LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);

各参数如下：
l参数pfnThreadProc是线程执行体函数，函数原形为: UINT ThreadFunction( LPVOID pParam)。
l参数pParam是传递给执行函数的参数；
l参数nPriority是线程执行权限，可选值：
THREAD_PRIORITY_NORMAL、THREAD_PRIORITY_LOWEST、THREAD_PRIORITY_HIGHEST、THREAD_PRIORITY_IDLE。
l参数dwCreateFlags是线程创建时的标志，可取值CREATE_SUSPENDED，表示线程创建后处于挂起状态，调用ResumeThread函数后线程继续运行，或者取值“0”表示线程创建后处于运行状态。
l返回值是CWinThread类对象指针，它的成员变量m_hThread为线程句柄，在Win32 API方式下对线程操作的函数参数都要求提供线程的句柄，所以当线程创建后可以使用所有Win32 API函数对pWinThread->m_Thread线程进行相关操作。

注意：如果在一个类对象中创建和启动线程时，应将线程函数定义成类外的全局函数（或者类中的静态函数似乎也可以）。

2.线程悬挂和恢复 / 优先级操作：同上。

3.线程退出：当调用线程的函数返回后，线程自动终止。

//线程可以在自身内部调用来终止自身的运行。
void AfxEndThread(UINT nExitCode, BOOL bDelete = TRUE);
//可以在线程的外部调用来强行终止一个线程的运行。
BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode );

注意：
(1)使用TerminateThread后，需调用CloseHandle( )函数释放线程所占用的堆栈。
(2)释放资源后，将线程HANDLE置成NULL。


进程间通信

1.全局变量方式：
(1)进程和线程共享全局变量，可利用该全局变量达到通信的目的。
(2)将进程的HADNLE作为参数传递给线程函数，然后线程可根据此HANDLE对进程的变量进行操作。

2.消息通信方式：

BOOL PostMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL PostThreadMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);

显然它们发送到的对象不同：PostMessage发消息给窗口，PostThreadMessage发消息给线程。且当PostThreadMessage的hWnd = NULL时，表明该消息传递给当前线程本身。 
BOOL   PostMessage(   UINT   message,   WPARAM   wParam   =   0,   LPARAM   lParam   =0   );  
返回值如果公布了消息，则返回非零值；否则返回0。   
参数message指定了要公布的消息。  
wParam指定了附加的消息信息。这个参数的内容依赖于要公布的消息。  
lParam指定了附加的消息信息。这个参数的内容依赖于要公布的消息。  
说明：这个函数将一个消息放入窗口的消息队列，然后直接返回，并不等待对应的窗口处理消息。消息队列中的消息是通过调用Windows的GetMessage或PeekMessage函数来获得的。可以通过Windows的PostMessage函数来访问其它应用程序。   
   
BOOL   PostThreadMessage(   UINT   message   ,   WPARAM   wParam,   LPARAMlParam   );返回值如果成功，则返回非零值；否则返回0。  
参数message用户自定义消息的ID。  
wParam第一个消息参数。  
lParam第二个消息参数。  
说明：调用这个函数以向其它CWinThread对象发送一个用户自定义消息。发送的消息通过消息映射宏ON_THREAD_MESSAGE被映射到适当的消息处理函数。   

3.同步方式：具体参见http://www.cppblog.com/andxie99/archive/2006/10/10/13517.html。

wchar_t c = `A' ; 
wchar_t * p = L"Hello!" ; 
wchar_t a[] = L"Hello!" ; 

以strcpy函数为例子，总结一下：

//如果你想使用ANSI字符串，那么请使用这一套写法：
char szString[100];
strcpy(szString,"test");
//如果你想使用Unicode字符串，那么请使用这一套：
wchar_t szString[100];
wcscpy(szString,L"test");
//如果你想通过定义_UNICODE宏，而编译ANSI或者Unicode字符串代码：
TCHAR szString[100];
_tcscpy(szString,_TEXT("test"));

//char* to string : 
char *a = "abcde";
string str = a;

//string to char*
char *a = str.c_str();

//wchar_t* to wstring
wchar_t *b = L"abcde";
wstring wstr = b;

//wstring to wchar_t*
wchar_t *b = wstr.c_str();

//wstring to string 
std::string ws2s(const std::wstring& ws)
{
    std::string curLocale = setlocale(LC_ALL, NULL);      
        setlocale(LC_ALL, "chs");
        const wchar_t* _Source = ws.c_str();
        size_t _Dsize = 2 * ws.size() + 1;
        char *_Dest = new char[_Dsize];
        memset(_Dest,0,_Dsize);
        wcstombs(_Dest,_Source,_Dsize);
        std::string result = _Dest;
        delete []_Dest;
        setlocale(LC_ALL, curLocale.c_str());

        return result;
}

//string to wstring
std::wstring s2ws(const std::string& s)
{
      setlocale(LC_ALL, "chs"); 
      const char* _Source = s.c_str();
      size_t _Dsize = s.size() + 1;
      wchar_t *_Dest = new wchar_t[_Dsize];
      wmemset(_Dest, 0, _Dsize);
      mbstowcs(_Dest,_Source,_Dsize);
      std::wstring result = _Dest;
      delete []_Dest;
      setlocale(LC_ALL, "C");

      return result;
}