C++ 之要点总结

1.windows环境在运行程序后就自动关闭窗口问题。
我们可以让窗口一直打开知道按下ENTER键。解决方法是：在return语句后加上一行代码：cin.get();或者用systerm（”pause”）;

2.头文件名新老标准：
c++旧式风格：以.h结尾 举例：iostream.h
c++新式风格 ： 没有扩展名 举例：iostream
新式风格下，cout,cin的使用。1）std::cout<<”…..”;2)函数体内开头加上using namespace std;后面的代码就可以直接使用cout<<”…”;3用using声明只是所需的名称。例using std::cout;
3.
在C++中内置类型有：
整型：
①整数 int、short和long
②字符型 char和wchar_t
③布尔型 bool
整型可用修饰：unsigned
浮点：
float、double和long double
记住：string不是内置类型。

4.new 对象数组初始化

string *psa = new string[10];      //array of 10 empty strings
int *pia = new int[10];           //array of 10 uninitialized ints
int *pia = new int[10]（）; //array of 10 empty ints

第一个数组是 string 类型，分配了保存对象的内存空间之后，将调用 string 类型的默认构造函数依次初始化数组中每个元素；第二个是申请具有内置类型的数组，分配了存储 10 个 int 对象的内存空间，但并没有初始化。
对于内置类型而言，new仅仅是分配内存，除非后面显示加(),相当于调用它的构造函数，对于自定义类型而言，只要一调用new，那么编译器不仅仅给它分配内存，还调用它的默认构造函数初始化，即使后面没有加()

5.枚举类型

enum string{    
    x1,    
    x2,    
    x3=10,    
    x4,    
    x5,    
} x;

函数外部，x为0，函数内部x 为随机数
enum 枚举名{
标识符[=整型常数],
标识符[=整型常数],

…
标识符[=整型常数],

} 枚举变量;
如果枚举没有初始化, 即省掉”=整型常数”时, 则从第一个标识符开始,
依次赋给标识符0, 1, 2, …。但当枚举中的某个成员赋值后, 其后的成员按依次加1的规则确定其值。
例如下列枚举说明后, x1, x2, x3, x4的值分别为0, 1, 2, 3。
enum string{x1, x2, x3, x4}x;

详细请点：C语言枚举类型详解
6. 变量地址转换

unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;

p1=(unsigned char*)0x801000;
是给指针变量赋值，即把十六进制0x801000放到字符指针变量中，即指针变量p1的值就是0x801000
输出结果p1+5的值是801005，因为指针变量指向的值字符，加一表示指针向后移动一个字节，那么加5代表向后移动5个字节，所以输入801005
p5+5的值是801016，因为指针变量指向的长整形的，加一表示指针向后移动4个字节，那么加5代表向后移动20个字节，所以输入810014，（输出时十六进制）要是十进制就是810020了
地址加1，单位是类型长度。

cout输出字符变量的地址需要进行类型转换，cout char*类型的指针值就理解为串输出。

#include <iostream>
using namespace std;

int main()
{
    int m = 59;
    char *name = "yuting";
    cout << &m << endl;
    cout << (void *)name << endl;
}

7.全局变量，静态局部变量，局部变量空间的堆分配和栈分配
设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为 A B D C

C c;
void main()
{
    A*pa=new A();
    B b;
    static D d;
    delete pa;
}

这道题主要考察的知识点是 ：全局变量，静态局部变量，局部变量空间的堆分配和栈分配

其中全局变量和静态局部变量时从 静态存储区中划分的空间，
二者的区别在于作用域的不同，全局变量作用域大于静态局部变量（只用于声明它的函数中），
而之所以是先释放 D 再释放 C的原因是， 程序中首先调用的是 C的构造函数，然后调用的是 D 的构造函数，析构函数的调用与构造函数的调用顺序刚好相反。

局部变量A 是通过 new 从系统的堆空间中分配的，程序运行结束之后，系统是不会自动回收分配给它的空间的，需要程序员手动调用 delete 来释放。

局部变量 B 对象的空间来自于系统的栈空间，在该方法执行结束就会由系统自动通过调用析构方法将其空间释放。

之所以是 先 A 后 B 是因为，B 是在函数执行到 结尾 “}” 的时候才调用析构函数， 而语句 delete a ; 位于函数结尾 “}” 之前。

8 . sizeof(类)，类占用内存大小
若char是一字节，int是4字节，指针类型是4字节，代码如下：

class CTest
{
    public:
        CTest():m_chData(‘\0’),m_nData(0)
        {
        }
        virtual void mem_fun(){}
    private:
        char m_chData;
        int m_nData;
        static char s_chData;
};
char CTest::s_chData=’\0’;

问：
（1）若按4字节对齐sizeof(CTest)的值是多少？
（2）若按1字节对齐sizeof(CTest)的值是多少？
请选择正确的答案。
12,9
解释：
1 先找有没有virtual 函数，有的话就要建立虚函数表，+4
2 static的成员变量属于类域被类所有实例所共享的，它不计入sizeof计算的空间 +0
3 什么成员函数或变量都没有的类，或者只有成员函数 +1
4 类中的普通函数或静态普通函数都存储在代码区中，不计入sizeof计算的空间
12= 4（虚表指针）+1（char )+3(对齐补位）+4（int)
9 = 4（虚表指针）+1（char )+4（int)
如果想用程序输出变量的地址，可以这样做：

printf("%p\n",&CTest::m_chData); 
//此处输出m_chData的内存地址。printf函数族中对于%p一般以十六进制整数方式输出指针的值，附加前缀0x。 

sizeof(string)
使用标准C++中string类，必须要包含

#include <string> 头文件

string的实现在各库中可能有所不同，但是在同一库中相同一点是，无论你的string里放多长的字符串，它的sizeof()都是固定的，字符串所占的空间是从堆中动态分配的，与sizeof()无关。 sizeof(string)=4可能是最典型的实现之一，不过也有sizeof()为12、32字节的库实现。
测试验证：

 string str_test1;
 string str_test2 = "Hello World";
 int value1, value2, value3;
 value1 = sizeof(str_test1);
 value2 = sizeof(str_test2);
 value3 = sizeof(string);
 cout<<"str_test1占 "<<value1<<" 个字节"<<endl;
 cout<<"str_test2占 "<<value2<<" 个字节"<<endl;
 cout<<"string占 "<<value3<<" 个字节"<<endl;

在win32系统，vs2010测试得到：

9.　时间复杂度与初始排序无关的算法
常见的几种排序算法复杂度如下：
方式： 平均　　　最坏　　　最好
插入 　 n^2 　　　n^2 　　 n
希尔 　n^1.3　　　 / 　　　 /
冒泡 　n^2　　　n^2　　　 n
快速 　nlogn　　n^2　　　 nlogn
选择 　n^2 　　　n^2　　　n^2
堆排 　nlogn　　nlogn　　 nlogn
归并 　nlogn　　 nlogn　　 nlogn
基数 　d(n+r)　　d(n+r)　　d(n+r)

其中最好、最坏、平均三项复杂度全是一样的就是与初始排序无关的排序方法，也就是：
选择排序、堆排、归并、基数
10. 运算符优先级
百度百科-运算符优先级
11. ASCII码
在计算机中，所有的数据在存储和运算时都要使用二进制数表示。为了方便，每个字符与二进制相对应。得到承认的编码规则就是ASCII码。标准ASCII 码也叫基础ASCII码，使用7 位二进制数（0~127）来表示所有的大写和小写字母，数字0 到9、标点符号， 以及在美式英语中使用的特殊控制字符。还有128个称为扩展ASCII码。

12.转义字符的表示
所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。例如 ‘\041’;即用八进制表示的字符“！”。一般而言，八进制前面以0开头，但这儿41前面的0可以去掉。C/C++规定不允许使用斜杠加10进制数来表示字符。’\x2f’表示用十六进制表示的转义字符“！”。
13. sizeof(指针)与sizeof(数组)

#include <stdio.h>
#include <string.h>

int main (int argc, char** argv)
{
        char as[10];
        char as2[10][20];
        char * ps = as;
        char *pa[10];
        char (*ppa)[10];
        char *pc = "hello";
        char pac[] = "hello";
        /* as与ps是有本质区别的,ps仅仅是一个字符指针,而as则指代由10个char */
        /* 组成的字符数组 */
        printf("sizeof(as)=%d\n", sizeof(as)); //10
        printf("sizeof(ps)=%d\n", sizeof(ps)); //4

        /* 同理,as2[0]指代由20个char组成的字符数组 */
        /* as2指代整个二维字符数组 */
        printf("sizeof(as2[0])=%d\n", sizeof(as2[0])); //20
        printf("sizeof(as2)=%d\n", sizeof(as2)); //200

        /* pa是由10个字符指针组成的数组 */
        /* *pa是这个数组中的第一个元素 */
        printf("sizeof(pa)=%d\n", sizeof(pa)); //40
        printf("sizeof(*pa)=%d\n", sizeof(*pa)); //4

        /* ppa是一个指向由10个char组成的数组的指针 */
        /* (*ppa)才是指代整个数组 */
        printf("sizeof(ppa)=%d\n", sizeof(ppa)); // ** 4
        printf("sizeof(*ppa)=%d\n", sizeof(*ppa));//10

        /* pc只是一个字符指针, (*pc)是一个字符 */
        printf("sizeof(pc)=%d\n", sizeof(pc)); // 4
        printf("sizeof(*pc)=%d\n", sizeof(*pc)); //1

        /* pac则是一个字符数组, 注意它的大小是6,而不是5,因为后面会自动加一个'\0' */
        printf("sizeof(pac)=%d\n", sizeof(pac));//6
}

13 二维动态数组vector
对于vector<vector<int> > array；其表示的是二维动态数组。
如何得到数组的维数？我们知道一维是行，二维是列
所以我们可以这样：

int rows = array.size();
int cols = array[0].size();

创建二维动态数组方法：

    int row=2,col=4;  
    vector<vector<int> > v(row);//v为容器的容器，大小为2. 
    for(int i=0; i<row; i++)  
        v[i].resize(col);//里层容器大小设置为4 

二维动态数组赋值方法：

for(int i=0; i<row; i++)//初始化元素的值 
    for(int j=0; j<col; j++)  
        v[i][j]=i*col+j+1; 

初始化二维数组

vector<vector <int> > ivec(m ,vector<int>(n,0));    //m*n的二维vector，所有元素为0