C/C++求职宝典21个重点笔记（常考笔试面试点）

static关键字：

1）函数体内static变量的作用范围为函数体。不同于auto变量。该变量的内存只被分配一次。因此其值在下次调用时仍维持上次的值。

2）在模块内的static全局变量可以被模块内的所有函数访问。但不能被模块外的其他函数访问。

3）在模块内的static函数只可被这一模块内的其它函数调用。这个函数的使用范围被限制在声明它的模块内。

4）在类中的static成员变量属于整个类所有，对类的所有对象只有一份复制。

5）在类中的static成员函数属于整个类所有，这个函数不接受this指针，因而只能访问类的static成员变量。

const关键字：

1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化。因为以后就没有机会再改变它了。

2）对指针来说，可以指定指针的本身为const，也可以指定指针所指向的数为const。或二者同时为const。

3）在一个函数的声明中，const可以修饰形参，表明它是一个输入参数。在函数内不能改变其值。

4）对于类的成员函数，若指定其为const类型。则表明其是一个常量函数。不能修改类的成员变量。

5）对于类的成员函数，有时候必须指定其返回值为const类型。以使得其返回值不为“左值”。

#include <stdio.h>

int main() {
    int a[] = {10, 6, 9, 5, 2, 8, 4, 7, 1, 3};
    int i, tmp;
    int len = sizeof(a) / sizeof(a[0]);
    for(i = 0; i < len;) {
        tmp = a[a[i] - 1];
        a[a[i] - 1] = a[i];
        a[i] = tmp;
        if(a[i] == i + 1) i++;
    }
    for(i = 0; i < len; ++i)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}

double modf(double num, double *i); // 将num分解为整数部分*i和小数部分（返回值决定）

 int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 int *p = &(a + 1)[3];
 printf("%d\n", *p);

输出：5 
说明：因为a+1指向a的第二个元素，[3]表示再向后移动3个元素。

 char str1[] = "abc";
 char str2[] = "abc";
 const char str3[] = "abc";
 const char str4[] = "abc";
 const char *str5 = "abc";
 const char *str6 = "abc";
 char *str7 = "abc";
 char *str8 = "abc";
 cout << (str1 == str2) << endl;
 cout << (str3 == str4) << endl;
 cout << (str5 == str6) << endl;
 cout << (str7 == str8) << endl;

输出：0 0 1 1 
说明：输出str1~str8的地址为：

0x23aa80 
0x23aa70 
0x23aa60 
0x23aa50 
0x23aa48 
0x23aa40 
0x23aa38 
0x23aa30

输出str1~str8内容“abc”的存储地址为：

0x23aa80 
0x23aa70 
0x23aa60 
0x23aa50 
0x100403030 
0x100403030 
0x100403030 
0x100403030

可以发现str1~str4中的内容是存在栈上，地址各不相同，而str5~str8的内容都是存储在常量区，所以地址都相同。

注意：

char *str = "abc";
printf("%p\n", str1);
cout << &str1 << endl;

上面打印的是字符串 “abc”的地址，下面打印的是 str1 变量的地址。

（1）C的结构体内不允许有函数存在，C++允许有内部成员函数，且允许该函数是虚函数。所以C的结构体是没有构造函数、析构函数、和this指针的。 
（2）C的结构体对内部成员变量的访问权限只能是public，而C++允许public,protected,private三种。 
（3）C语言的结构体是不可以继承的，C++的结构体是可以从其他的结构体或者类继承过来的。

以上都是表面的区别，实际区别就是面向过程和面向对象编程思路的区别：

C的结构体只是把数据变量给包裹起来了，并不涉及算法。 
而C++是把数据变量及对这些数据变量的相关算法给封装起来，并且给对这些数据和类不同的访问权限。 
C语言中是没有类的概念的，但是C语言可以通过结构体内创建函数指针实现面向对象思想。

class CBook {
public:
    const double m_price;
    CBook() :m_price(8.8) { }
};

下面的做法是错误的：

class CBook {
public:
    const double m_price;
    CBook() {
        m_price = 8.8;
    }
};

而下面的做法虽未报错，但有个warning，也不推荐：

class CBook {
public:
    const double m_price = 8.8; // 注意这里若没有const则编译出错
    CBook() { }
};

class CBook {
public:
    mutable double m_price;  // 如果不加就会出错
    CBook(double price) :m_price(price) { }
    double getPrice() const; // 定义const方法
};
double CBook::getPrice() const {
    m_price = 9.8;
    return m_price;
}

class CBook {
public:
    CBook() {
        cout << "constructor is called.\n";
    }
    ~CBook() {
        cout << "destructor is called.\n";
    }
};

void invoke(CBook book) { // 对象作为函数参数，如果这里加了个&就不是了，因为加了&后是引用方式传递，形参和实参指向同一块地
                          // 址，就不需要创建临时对象，也就不需要调用拷贝构造函数了
    cout << "invoke is called.\n";
}

int main() {
    CBook c;
    invoke(c);
}

解答：注意拷贝构造函数在对象作为函数参数传递时被调用，注意是对象实例而不是对象引用。因此该题输出如下：

constructor is called.
invoke is called.
destructor is called.  // 在invoke函数调用结束时还要释放拷贝构造函数创建的临时对象，因此这里还调用了个析构函数
destructor is called.  

引申：拷贝构造函数在哪些情况下被调用？ 
（1）函数的参数为类对象且参数采用值传递方式； 
（2）将类对象做为函数的返回值。

class CBook {
public:
    double m_price;
    CBook() {
        CBook(8.8);
    }
    CBook(double price) : m_price(price) { }
};
int main() {
    CBook c;
    cout << c.m_price << endl;  // 此时并不会输出理想中的8.8
}

class CBook {
public:
    static double m_price;
};
double CBook::m_price = 8.8;  // 只能在这初始化，不能在CBook的构造函数或直接初始化

引申：重载++和–时是怎么区分前缀++和后缀++的？ 
例如当编译器看到++a（先自增）时，它就调用operator++(a); 
但当编译器看到a++时，它就调用operator++(a, int)。即编译器通过调用不同的函数区别这两种形式。

class A {
public:
    virtual void funa();
    virtual void funb();
    void func();
    static void fund();
    static int si;
private:
    int i;
    char c;
};

问：sizeof(A) = ?

解答： 
关于类占用的内存空间，有以下几点需要注意： 
（1）如果类中含有虚函数，则编译器需要为类构建虚函数表，类中需要存储一个指针指向这个虚函数表的首地址，注意不管有几个虚函数，都只建立一张表，所有的虚函数地址都存在这张表里，类中只需要一个指针指向虚函数表首地址即可。 
（2）类中的静态成员是被类所有实例所共享的，它不计入sizeof计算的空间 
（3）类中的普通函数或静态普通函数都存储在栈中，不计入sizeof计算的空间 
（4）类成员采用字节对齐的方式分配空间

答案：12（32位系统）或16（64位系统）