C++: Basic knowledge Part 1

1、在 C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”？

    首先，extern 是 C/C++ 语言中表明函数和全局变量作用范围的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。
    通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字 extern 声明。extern "C" 是连接申明(linkage declaration)，被 extern "C" 修饰的变量和函数是按照 C 语言方式编译和连接的。作为一种面向对象的语言，C++ 支持函数重载，而过程式语言 C 则不支持。函数被 C++ 编译后在符号库中的名字与 C 语言的不同。例如，假设某个函数的原型为：void foo( int x, int y ); 该函数被 C 编译器编译后在符号库中的名字为 _foo，而 C++ 编译器则会产生像 _foo_int_int 之类的名字。这样的名字包含了函数名、函数参数数量及类型信息，C++ 就是靠这种机制来实现函数重载的。
    所以，可以用一句话概括extern “C”这个声明的真实目的：解决名字匹配问题，实现 C++ 与 C 的混合编程。

 

2、头文件中的 ifndef/define/endif 有什么作用？
    这是 C++ 预编译头文件保护符，保证即使文件被多次包含，头文件也只定义一次。

 

3、#include<file.h> 与 #include "file.h" 有什么区别？
    前者是从标准库路径寻找和引用 file.h，而后者是从当前工作路径搜寻并引用 file.h。

 

4、评价 C、C++ 各自的特点。
    C 语言是一种结构化语言，面向过程，基于算法和数据结构，所考虑的是如何通过一个过程或者函数从输入得到输出；
    C++ 是面向对象，基于类、对象和继承，所考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题，通过获取对象的状态信息得到输出或实现过程控制。

 

5、const 有什么用途？
    在C/C++中，
    （1）可以定义const常量；
    （2）修饰函数的返回值和形参；
    在C++中，还可以修饰函数的定义体，定义类的 const 成员函数。被 const 修饰的东西受到强制保护，可以预防意外的变动，提高了程序的健壮性。

 

6、const 和 #define 有什么区别？
    （1）const 和 #define 都可以定义常量，但是 const 用途更广。
    （2）const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
    （3）有些集成化的调试工具可以对 const 常量进行调试，但是不能对宏常量进行调试。

 

7、sizeof 小结
    sizeof 计算的是在栈中分配的内存大小。
    （1） sizeof 不计算 static 变量占的内存；
    （2） 指针的大小一定是 4 个字节，而不管是什么类型的指针；
    （3） char 型占 1 个字节，int 占 4 个字节，short int 占 2 个字节，long int 占 4 个字节，float 占 4 字节，double 占 8 字节，string占 4 字节；一个空类占 1 个字节，单一继承的空类占 1 个字节，虚继承涉及到虚指针所以占 4 个字节；
    （4） 数组的长度：
    若指定了数组长度，则不看元素个数，总字节数 = 数组长度 * sizeof（元素类型）；
    若没有指定长度，则按实际元素个数类确定；
    Ps：若是字符数组，则应考虑末尾的空字符。
    （5） 结构体对象的长度
    在默认情况下，为方便对结构体内元素的访问和管理，当结构体内元素长度小于处理器位数的时候，便以结构体内最长的数据元素的长度为对齐单位，即为其整数倍。若结构体内元素长度大于处理器位数则以处理器位数为单位对齐。
    （6） unsigned 影响的只是最高位的意义，数据长度不会改变，所以 sizeof(unsigned int)= 4;
    （7） 自定义类型的 sizeof 取值等于它的类型原型取 sizeof
    （8） 对函数使用 sizeof，在编译阶段会被函数的返回值的类型代替
    （9） sizeof 后如果是类型名则必须加括号，如果是变量名可以不加括号，这是因为 sizeof 是运算符;
    （10） 当使用结构类型或者变量时，sizeof 返回实际的大小。当使用静态数组时返回数组的全部大小，sizeof 不能返回动态数组或者外部数组的尺寸。

 

8、sizeof 与 strlen 的区别？
    （1）sizeof 的返回值类型为 size_t(unsigned int)；
    （2）sizeof 是运算符，而 strlen 是函数；
    （3）sizeof 可以用类型做参数，其参数可以是任意类型的或者是变量、函数，而 strlen 只能用 char* 做参数，且必须是以 ’’ 结尾；
    （4）数组作 sizeof 的参数时不会退化为指针，而传递给 strlen 是就退化为指针；
    （5）sizeof 是编译时的常量，而 strlen 要到运行时才会计算出来，且是字符串中字符的个数而不是内存大小。

 

9、指针和引用的区别？
    指针和引用都提供了间接操作对象的功能。
    （1） 指针定义时可以不初始化，而引用在定义时就要初始化，和一个对象绑定，而且一经绑定，只要引用存在，就会一直保持和该对象的绑定；
    （2） 赋值行为的差异：指针赋值是将指针重新指向另外一个对象，而引用赋值则是修改对象本身；
    （3） 指针之间存在类型转换，而引用分 const 引用和非 const 引用，非 const 引用只能和同类型的对象绑定，const 引用可以绑定到不同但相关类型的对象或者右值。

 

10、数组和指针的区别？
    （1）数组要么在全局数据区被创建，要么在栈上被创建；指针可以随时指向任意类型的内存块；
    （2）修改内容上的差别：
    char a[] = “hello”;
    a[0] = ‘X’;
    char *p = “world”; // 注意 p 指向常量字符串
    p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
    (3)用运算符 sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是 p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

 

11、空指针和悬垂指针的区别？
    空指针是指被赋值为 NULL 的指针；delete 指向动态分配对象的指针将会产生悬垂指针。
    （1）空指针可以被多次 delete，而悬垂指针再次删除时程序会变得非常不稳定；
    （2）使用空指针和悬垂指针都是非法的，而且有可能造成程序崩溃，如果指针是空指针，尽管同样是崩溃，但和悬垂指针相比是一种可预料的崩溃。

 

12、C++中有 malloc/free，为什么还有 new/delete？
    malloc/free 是 C/C++ 标准库函数，new/delete 是 C++ 运算符。他们都可以用于动态申请和释放内存。
    对于内置类型数据而言，二者没有多大区别。malloc 申请内存的时候要制定分配内存的字节数，而且不会做初始化；new 申请的时候有默认的初始化，同时可以指定初始化；
    对于类类型的对象而言，用 malloc/free 无法满足要求的。对象在创建的时候要自动执行构造函数，消亡之前要调用析构函数。由于 malloc/free 是库函数而不是运算符，不在编译器控制之内，不能把执行构造函数和析构函数的任务强加给它，因此，C++ 还需要 new/delete。

 

13、什么是智能指针？
    当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。
　　智能指针的一种通用实现技术是使用引用计数。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。
　　每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

 

14、面向对象技术的基本概念是什么，三个基本特征是什么？
    基本概念：类、对象、继承； 基本特征：封装、继承、多态。
    封装：将低层次的元素组合起来形成新的、更高实体的技术；
    继承：广义的继承有三种实现形式：实现继承、可视继承、接口继承；
    多态：允许将子类类型的指针赋值给父类类型的指针。

 

15、C++ 空类默认有哪些成员函数？
    默认构造函数、析构函数、复制构造函数、赋值函数。

 

16、哪一种成员变量可以在一个类的实例之间共享？
    static 静态成员变量

 

17、继承层次中，为什么基类析构函数是虚函数？
    编译器总是根据类型来调用类成员函数。但是一个派生类的指针可以安全地转化为一个基类的指针。这样删除一个基类的指针的时候，C++ 不管这个指针指向一个基类对象还是一个派生类的对象，调用的都是基类的析构函数而不是派生类的。如果你依赖于派生类的析构函数的代码来释放资源，而没有重载析构函数，那么会有资源泄漏。

 

18、为什么构造函数不能为虚函数？
    虚函数采用一种虚调用的方法。虚调用是一种可以在只有部分信息的情况下工作的机制。如果创建一个对象，则需要知道对象的准确类型，因此构造函数不能为虚函数。

 

19、为什么不把所有函数设为虚函数？什么函数不能声明为虚函数？为什么？
    不行。首先，虚函数是有代价的，由于每个虚函数的对象都要维护一个虚函数表，因此在使用虚函数的时候都会产生一定的系统开销，这是没有必要的。 
    静态成员函数不能是虚函数：虚函数是为了多态设计的，静态成员函数独立于对象存在，没有 this 指针，所以不能设计成虚函数. 
    内联函数不能为虚函数：
    构造函数不能是虚函数。

 

20、构造函数可以是内联函数吗？
    一般情况下，构造函数比较小的情况下，不管你是否指定其为内联函数，C++ 编译器会自动将其置为内联，如果函数太大，你即使将其指定为内联函数系统也会不理的。因为这会使程序过大。

 

21、什么是多态？多态有什么作用？
    多态就是将基类类型的指针或者引用指向派生类型的对象。多态通过虚函数机制实现。
    多态的作用是接口重用。

 

22、重载和覆盖有什么区别？
    虚函数是基类希望派生类重新定义的函数，派生类重新定义基类虚函数的做法叫做覆盖；
    重载就在允许在相同作用域中存在多个同名的函数，这些函数的参数表不同。重载的概念不属于面向对象编程，编译器根据函数不同的形参表对同名函数的名称做修饰，然后这些同名函数就成了不同的函数。
    重载的确定是在编译时确定，是静态的；虚函数则是在运行时动态确定。

 

23、公有继承、受保护继承、私有继承有什么区别？
    （1）公有继承时，派生类对象可以访问基类中的公有成员，派生类的成员函数可以访问基类中的公有和受保护成员；基类受保护的成员，可以通过派生类对象访问但不能修改；
    （2）私有继承时，基类的成员只能被直接派生类的成员访问，无法再往下继承；
    （3）受保护继承时，基类的成员也只被直接派生类的成员访问，无法再往下继承。

 

24、sprintf、strcpy、memcpy 函数有什么区别？
    这些函数的区别在于 实现功能以及操作对象不同。
    （1）strcpy 函数操作的对象是字符串，完成从源字符串到目的字符串的拷贝功能。
    （2）sprintf 函数操作的对象不限于字符串：虽然目的对象是字符串，但是源对象可以是字符串、也可以是任意基本类型的数据。这个函数主要用来实现（字符串或基本数据类型）向字符串的转换功能。如果源对象是字符串，并且指定 %s 格式符，也可实现字符串拷贝功能。
    （3）memcpy 函数顾名思义就是内存拷贝，实现将一个内存块的内容复制到另一个内存块这一功能。内存块由其首地址以及长度确定。程序中出现的实体对象，不论是什么类型，其最终表现就是在内存中占据一席之地（一个内存区间或块）。因此，memcpy 的操作对象不局限于某一类数据类型，或者说可适用于任意数据类型，只要能给出对象的起始地址和内存长度信息、并且对象具有可操作性即可。鉴于memcpy 函数等长拷贝的特点以及数据类型代表的物理意义，memcpy 函数通常限于同种类型数据或对象之间的拷贝，其中当然也包括字符串拷贝以及基本数据类型的拷贝。
    对于字符串拷贝来说，用上述三个函数都可以实现，但是其实现的效率和使用的方便程度不同：
    strcpy 无疑是最合适的选择：效率高且调用方便。
    sprintf 要额外指定格式符并且进行格式转化，麻烦且效率不高。
    memcpy 虽然高效，但是需要额外提供拷贝的内存长度这一参数，易错且使用不便；并且如果长度指定过大的话（最优长度是源字符串长度 + 1），还会带来性能的下降。其实 strcpy 函数一般是在内部调用 memcpy 函数或者用汇编直接实现的，以达到高效的目的。因此，使用 memcpy 和 strcpy 拷贝字符串在性能上应该没有什么大的差别。
    对于非字符串类型的数据的复制来说，strcpy 和 snprintf 一般就无能为力了，可是对 memcpy 却没有什么影响。但是，对于基本数据类型来说，尽管可以用 memcpy 进行拷贝，由于有赋值运算符可以方便且高效地进行同种或兼容类型的数据之间的拷贝，所以这种情况下 memcpy 几乎不被使用 。memcpy 的长处是用来实现（通常是内部实现居多）对结构或者数组的拷贝，其目的是或者高效，或者使用方便，甚或两者兼有。

 

25、有哪几种情况只能用构造函数初始化列表而不能用赋值初始化？
    const 成员，引用成员。

 

26、什么是虚指针？
    虚指针或虚函数指针是虚函数的实现细节。带有虚函数的每一个对象都有一个虚指针指向该类的虚函数表。

 

27、C++ 如何阻止一个类被实例化？一般在什么时候将构造函数声明为 private？
    （1）将类定义为抽象基类或者将构造函数声明为 private；
    （2）不允许类外部创建类对象，只能在类内部创建对象。

 

28、main函数执行之前会执行什么？执行之后还能执行代码吗？
    （1）全局对象的构造函数会在 main 函数之前执行；
    （2）可以，可以用_onexit 注册一个函数，它会在 main 之后执行;
    如果你需要加入一段在 main 退出后执行的代码，可以使用 atexit() 函数，注册一个函数。

#include <stdlib.h>
#include <stdio.h>

int atexit(void (*function")(void));
void fn1( void ), fn2( void ), fn3( void );

int main( void )
{
    atexit(fn1);
    atexit( fn2 );
    printf( "This is executed first.
" );
}

void fn1()
{
    printf( " This is
" );
}

void fn2()
{
    printf( " executed next." );
}

    结果：
This is executed first.
This is executed next.

 

29、经常要操作的内存分为那几个类别？
    （1）栈区：由编译器自动分配和释放，存放函数的参数值、局部变量的值等；
    （2）堆：一般由程序员分配和释放，存放动态分配的变量；
    （3）全局区（静态区）：全局变量和静态变量存放在这一块，初始化的和未初始化的分开放；
    （4）文字常量区：常量字符串就放在这里，程序结束自动释放；
    （5）程序代码区：参访函数体的二进制代码。

 

30、堆和栈的区别是什么？
    （1）申请方式不同。栈上有系统自动分配和释放；堆上有程序员自己申请并指明大小；
    （2）栈是向低地址扩展的数据结构，大小很有限；堆是向高地址扩展，是不连续的内存区域，空间相对大且灵活；
    （3）栈由系统分配和释放速度快；堆由程序员控制，一般较慢，且容易产生碎片。

31、求下面函数的返回值

int func(int x)
{ 
    int count = 0;
    while(x)
    { 
        ++count;
        x = x & (x - 1);
    }

    return count;
}

    假定 x = 9999。 答案：8

    思路：将 x 转化为 2 进制，看含有的 1 的个数。

32、分别写出 bool、int、float、指针类型的变量 a 与“零”的比较语句。

// bool
if (!a) { }
if(a) { }

// int
if (a == 0) { }

// float
const double EXPSILON = 1e-6;
if (a < EXPSILON && a > -EXPSILON) { }

// pointer
if (NULL != a) { }
if (NULL == a) { }

33、结构与联合

https://stackoverflow.com/questions/2310483/purpose-of-unions-in-c-and-c

https://stackoverflow.com/questions/1812348/a-question-about-union-in-c
https://stackoverflow.com/questions/740577/sizeof-a-union-in-c-c
https://stackoverflow.com/questions/346536/difference-between-a-structure-and-a-union/346541#346541
https://stackoverflow.com/questions/10747810/what-is-the-difference-between-typedef-and-using-in-c11
https://stackoverflow.com/questions/612328/difference-between-struct-and-typedef-struct-in-c/612350#612350
http://yixiangongzhu.blog.163.com/blog/static/1973632032011111545140752/
https://blog.csdn.net/wangyanguiyiyang/article/details/52504559

https://www.cnblogs.com/paulbai/articles/2711809.html

    union中的各个成员共用一块内存，而且这块内存的大小是和union中占空间最大的元素所占空间一样大，对union中不同成员的写操作，会覆盖其他成员的值。

区别：
    （1）结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。 
    （2）对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

以下程序的输出是什么？

#include <iostream>

union
{
    int i;
    char x[2];
} a;

int main()
{
    a.x[0] = 10;
    a.x[1] = 1;

    std::cout << a.i << std::endl;

    return 0;
}   

    266 (低位低地址，高位高地址，内存占用情况是0x010A）。

    sizeof(a) = 4，对x进行赋值，由于会分配4个字节(Byte)的空间，但是x只占用了两个字节(Byte)的空间，在赋值时从低地址开始。一个16进制数字占4位(bit，因为16=2^4)，即0.5个字节(Byte)，一个字节(Byte)有8位(bit)，在高位添0，所以a在内存中的分布式这样的：

    | 0A | 01 | 00 | 00 |
    低---------->高
从高位到低位读是：0x0000010A。当输出a.i时，由于占用同样一块内存，所以会读出4个字节，转化为10进制是266。

以下程序的输出是什么？

#include <iostream>
#include <iomanip>

union
{
    int i;
    struct
    {
        char first;
        char second;
    } half;
} number;

int main()
{
    number.i = 0x4241;
    std::cout << number.half.first << " " << number.half.second << std::endl;
    
    number.half.first = 'a';
    number.half.second = 'b';
    std::cout << std::hex << number.i << std::endl;

    return 0;
}

    AB(0x41对应'A',是低位；0x42对应'B',是高位）；

    6261(number.i 和 number.half 共用一块地址空间）。

34、找出以下程序的错误。

// Q
// Q1
void test1()
{
    char string[10];
    char* str1 = "0123456789";
    strcpy(string, str1);
} 


// Q2
void test2()
{
    char string[10], str1[10];
    int i;
    for (i = 0; i < 10; ++i)
    {
        str1 = 'a';
    }

    strcpy(string, str1);
}


// Q3
void test3(char* str1)
{
    char string[10];
    if (strlen(str1) <= 10)
    {
        strcpy(string, str1);
    }
}

解答：
    Q1：字符串 str1 需要 11 个字节才能存放下（包括末尾的’’），而 string 只有 10 个字节的空间，strcpy 会导致数组越界；
    Q2：字符数组 str1 不能在数组内结束；strcpy(string, str1) 调用使得从 str1 内存起复制到 string 内存起所复制的字节数具有不确定性；
    Q3：if(strlen(str1) <= 10) 应改为 if(strlen(str1) < 10)，因为 strlen 的结果未统计 ’’ 所占用的 1 个字节。

35、编写 strcpy 函数。
    已知 strcpy 函数的原型是
    char* strcpy(char *strDest, const char *strSrc);
    其中 strDest 是目的字符串，strSrc 是源字符串。

    （1）不调用 C/C++ 的字符串库函数，请编写函数 strcpy
    （2）strcpy 能把 strSrc 的内容复制到 strDest，为什么还要 char* 类型的返回值？

#include <assert.h>
#include <stdio.h>
char* strcpy(char* strDest, constchar* strSrc)
{
    assert((NULL != strDest) && (NULL != strSrc));
    
    char* address = strDest;
    while((*strDest++ = *strSrc++) != '')
    {
        NULL;
    }

    return address;
}

    为了实现链式表达式。
    例如 int length = strlen( strcpy( strDest, “hello world”) );

36、编写 strlen 函数。

int strlen(const char* str)
{
    assert(NULL != str);

    int len = 0;
    while ((*str++) != '')
    {
        len++;
    }

    return len;
}

37、已知String类定义如下：

class String
{
public:
    String(const char *str = NULL);
    String(const String &rhs);
    ~String();
    String& operater =(const String &rhs);

private:
    char* m_data;
};

写出类的成员函数实现。

String::String(const char* str)
{
    if (NULL == str)
    {
        m_data = new char[1];
        *m_data = '';
    }

    m_data = new char[strlen(str) + 1];
    strcpy(m_data, str);
}


String::~String()
{
    delete []m_data;
}


String::String(const String& rhs)
{
    m_data = new char[strlen(rhs.m_data) + 1];
    strcpy(m_data, rhs.m_data);
}


String& String::operator=(const String& rhs)
{
    if (this == &rhs)
    {
        return *this;
    }

    delete []m_data;
    m_data = new char[strlen(rhs.m_data) + 1];
    strcpy(m_data, rhs.m_data);

    return *this;
}

38、找出以下程序的错误。

// Q1
void getMemory1(char* p)
{
    p = (char*)malloc(100);
}


void test1()
{
    char *str = NULL;
    getMemory1(str);
    strcpy(str, "hello world");
    printf(str);
}


// Q2
char* getMemory2()
{ 
    char p[] = "hello world";
    return p;
}


void test2()
{
    char* str = NULL;
    str = getMemory2();
    printf(str);
}


// Q3
void getMemory3(char** p, int num)
{
    *p = (char*)malloc(num);
}


void test3()
{
    char* str = NULL;
    getMemory3(&str, 100);
    strcpy(str, "hello");
    printf(str);
}


// Q4
void test4()
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    
    free(str);

    if(NULL != str)
    {
        strcpy(str, "world");
        printf(str);
    }
}

解答：

    Q1：因为 getMemory1 并不能传递动态内存，test1 函数中的 str 一直都是 NULL，strcpy(str, "hello world"); 将使程序崩溃；
    Q2：可能是乱码。因为getMemory2 返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原来的内容已经被清除，新内容不可知；
    Q3：能够输出 hello，但内存泄漏；
    Q4：篡改动态内存区的内容，后果难以预料，非常危险。因为 free(str); 之后，str 成为野指针，if(NULL != str) 语句不起作用。