c/c++笔试题总结

1.char*const*(*next)();如何理解这段代码

 解答：（*next）------>next是个指针

            （*next)()------->next是个函数指针

             char*const-------->返回的是一个指针，且是常量指针

    即char*const*(*next)();的理解为：next是个函数指针，指向一个没有参数的函数，并且该函数的返回值是一个指针，该指针指向一个类型为char 的常量指针。

2.int id[sizeof(unsigned long)]; 这个对吗？为什么？

 在C语言中，数组的大小必须是一个常量表达式，而sizeof(unsigned long)是一个运行时计算的值，因此不能用作数组的大小。正确的写法应该是unsigned long id[];，这样数组的大小会根据初始化时提供的元素个数自动确定。

3.如何理解静态成员变量static 

静态成员变量是属于类而不是属于类的实例的成员变量。它在类的所有实例之间共享，只有一份副本。当类被加载时，静态成员变量就会被分配内存空间，而不是在实例化对象时分配内存空间。

静态成员变量可以通过类名直接访问，也可以通过类的实例访问。它的生命周期与程序的生命周期相同，一直存在于程序运行期间。

静态成员变量通常用于存储与类相关的数据，例如计数器、全局配置等。静态成员变量的修改会影响所有实例的值，因此需要谨慎使用，避免引起意外的副作用。

4.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现？ 

 在C语言中可以使用宏定义如#define等，还可以使用内联函数来实现。内联函数是一种告诉编译器在调用处直接将函数代码插入的方式，避免了函数调用的开销。在函数声明前加上inline关键字即可定义一个内联函数。

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

 在C++中，除了可以使用内联函数外，还可以使用C++中的inline关键字定义内联函数外，还可以使用C++中的constexpr关键字。constexpr关键字用于声明函数或变量在编译时就能被计算出来的常量表达式。

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

5.如何理解回调函数

回调函数本身就是一个普通的函数，只不过它具有特殊的用途和功能。回调函数可以是任何合法的函数，包括用户自定义的函数、标准库函数或第三方库函数等。

回调函数通常被用作回调参数传递给另一个函数，以便在适当的时候被调用。回调函数可以执行任何操作，包括处理数据、更新状态、触发事件等。回调函数的功能取决于它的实现，可以根据需求编写不同的回调函数。

因此，回调函数本身可以是简单的一个函数，但在特定的上下文中，它可以发挥重要的作用，提供灵活性和可扩展性。通过回调函数，我们可以将代码模块化、降低耦合性，并实现更加灵活的程序设计。

#include <stdio.h>

// 回调函数的定义
void callback_function(int value) {
    printf("Callback function is called with value: %d\n", value);
}

// 接受回调函数作为参数的函数
void perform_operation(int value, void (*callback)(int)) {
    printf("Performing operation with value: %d\n", value);
    callback(value); // 调用回调函数
}

int main() {
    int input_value = 5;

    // 调用 perform_operation 函数，并传入回调函数 callback_function
    perform_operation(input_value, callback_function);

    return 0;
}

 6.void (*callback)(int)怎么理解

void (*callback)(int)是一个函数指针的声明，用来声明一个指向参数为int类型且返回类型为void的函数的指针。

让我们逐步解释这个声明：

• void：表示函数的返回类型为void，即函数没有返回值。
• (*callback)：使用*表示这是一个指针变量，callback是指针变量的名称。
• (int)：括号中的int表示函数的参数类型为int。

因此，void (*callback)(int)声明了一个函数指针callback，指向一个参数为int类型且返回类型为void的函数。通过这个函数指针，我们可以在程序中传递函数，并在需要的时候调用这个函数。

7.指针和引用有什么区别 

1.定义和语法：

• 指针是一个变量，存储另一个变量的内存地址。通过使用指针，可以间接访问和修改另一个变量的值。
• 引用是一个别名，它引用了另一个变量的内存地址。通过引用，可以直接访问和修改另一个变量的值，而不需要使用间接访问。

2.空值：

• 指针可以是空指针，即指向空地址或未初始化的指针。空指针通常用nullptr表示。
• 引用在定义时必须初始化，并且不能引用空值。

3.可变性：

• 指针可以重新赋值指向不同的变量或空地址。
• 引用在定义后不能改变引用的目标，即不能重新绑定到另一个变量。

3.操作符：

• 指针使用*操作符来访问指针指向的变量的值，使用&操作符来获取变量的地址。
• 引用不需要使用操作符来访问引用的值，因为它本身就是变量的别名。

4.传递参数：

• 通过指针传递参数时，函数可以修改传递的变量的值。
• 通过引用传递参数时，函数也可以修改传递的变量的值，并且不需要使用指针操作符。

8.c++中virtual与inline的含义分别是什么？

在C++中，virtual关键字用于声明一个函数为虚函数，这意味着该函数可以被子类重写。当在基类中声明一个函数为虚函数时，派生类可以通过覆盖该函数来提供自己的实现。

而inline关键字用于告诉编译器在函数被调用时进行内联展开，即将函数的代码插入到调用它的地方，而不是通过调用函数的方式执行代码。这可以减少函数调用的开销，但增加代码的大小。通常，较小且频繁调用的函数适合使用inline。

9.编译工具中的Debug与Release选项是什么含义？ 

 在编译工具中，通常有Debug和Release两种选项用于编译程序。

1. Debug模式：

• 在Debug模式下编译的程序会包含调试信息，这些信息可以帮助开发人员在程序出现问题时进行调试。
• 在Debug模式下编译的程序通常不做优化，编译出的代码更加易于调试，但可能执行速度较慢。
• Debug模式通常会开启一些检查功能，如边界检查、内存泄露检测等。

1. Release模式：

• 在Release模式下编译的程序会去除调试信息，减少程序的体积，提高程序的执行效率。
• Release模式会进行代码优化，以提高程序执行速度。
• 通常在发布正式版本时，会使用Release模式进行编译。

总之，Debug模式适合开发过程中进行调试和验证程序的正确性，而Release模式则适合生成最终发布版本，以提高程序的执行效率和减少体积。

10.函数assert的用法？ 

在C++中，assert是一个宏，用于在程序中插入断言（assertion），即在代码中检查一个条件是否为真。如果条件为假，assert会打印错误信息并终止程序的执行。assert通常在Debug模式下使用，用于在程序中添加断言检查，帮助开发人员在调试时找到问题所在。

assert的用法如下：

#include <cassert>

int main() {
    int x = 10;
    
    // 断言x是否大于0
    assert(x > 0);

    return 0;
}

在上述代码中，assert(x > 0)会检查x是否大于0，如果条件为假，则会打印错误信息，并通过调用std::abort函数终止程序的执行。如果条件为真，则程序会正常执行。

值得注意的是，assert宏在Release模式下通常会被忽略，即不会进行断言检查。所以在编写程序时，通常建议在Debug模式下进行断言检查，以帮助发现并修复潜在的问题。

11.const与#define的比较，const有什么优点？

 const和#define都可以用来定义常量，但是它们存在一些区别，const有一些优点：

1. 安全性：const定义的常量具有类型，而#define定义的常量是简单的文本替换。因此，使用const定义常量可以提供类型安全，避免意外的副作用。

2. 可读性：const定义的常量具有更好的可读性，可以清晰地表明常量的含义，而#define可能不易理解。

3. 作用域：const定义的常量具有作用域，在定义常量的代码块内有效，而#define定义的常量没有作用域限制，会在整个程序中起作用。

4. 调试：当程序中使用const定义常量时，调试器可以查看这些常量的值，而使用#define定义常量时，调试器不会显示相应的常量值。

综上所述，使用const而不是#define来定义常量可以带来更多的好处，如类型安全、可读性、作用域控制和调试方便等。因此，推荐在C++中使用const来定义常量。

12.有了malloc/free为什么还要new/delete? 

在C++中，malloc和free是C语言中用于分配和释放内存的函数，而new和delete是C++中用于分配和释放内存的运算符。虽然malloc和free与new和delete都可以用来动态分配和释放内存，但它们之间存在一些区别：

1. 类型安全性：new和delete是类型安全的运算符，能够根据分配的类型调用构造函数和析构函数，为对象分配内存并正确地初始化。而malloc和free是无类型的，它们只负责分配和释放内存，不会调用构造和析构函数。

2. 内存对齐：new会确保返回的内存地址满足特定类型的对齐要求，而malloc返回的地址没有这种保证，可能需要手动进行内存对齐操作。

3. 管理内存大小：malloc需要手动指定要分配的内存大小，而new会根据类型自动计算所需的内存大小。这样可以防止因为类型大小变化而忘记修改代码所产生的潜在错误。

4. 异常处理：new能够在分配内存失败时抛出异常，方便进行错误处理，而malloc在分配内存失败时只会返回nullptr，需要手动检查错误。

总的来说，使用new和delete能够更好地和C++的对象模型结合，提供更好的类型安全性、内存对齐和异常处理。因此，在C++中，推荐使用new和delete来进行动态内存的分配和释放。

13.如何处理内存耗尽的情况

处理内存耗尽的情况是一个非常重要的问题，特别是在编写对内存使用要求高的程序时。以下是一些处理内存耗尽的方法：

1. 优化内存使用：首先应该考虑优化程序的内存使用情况。检查是否有内存泄漏，释放不再需要的内存，或考虑重新设计算法以减少对内存的需求。

2. 使用内存池：内存池是一种预先分配一定量内存并进行管理的技术。当需要内存时先从内存池中申请，如果内存池无法满足需求，则可以自定义处理逻辑，比如释放内存池中的一部分内存再重新尝试分配。

3. 增加虚拟内存：在操作系统的设置中将虚拟内存调整为更大，可以在物理内存不足时使用磁盘作为虚拟内存。

4. 优雅处理内存分配失败：在申请内存时检查返回值是否为NULL，如果申请失败，应该根据程序的需求进行合理的异常处理。可以向用户显示友好的错误信息，记录日志，或者尝试释放其他不必要的内存。

5. 分配较小的内存块：如果无法找到足够大的内存块，可以尝试分配多个较小的内存块并进行组合使用。

6. 考虑使用内存分配失败的处理策略：根据具体情况，考虑采取恢复措施、重新尝试内存分配、优雅地退出程序等策略以确保程序的稳定性和可靠性。

14.c++是不是类型安全的？

不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。

15.const 符号常量；

1)const char *p
(2)char const *p
(3)char * const p
说明上面三种描述的区别；

1.const char *p: 这里声明了一个指向常量字符的指针 p。这意味着指针 p 可以指向一个字符，但不能通过 p 修改所指向的字符的值。也就是说，*p 是不可变的。（值不可改变）

2.char const *p: 这个声明与第一个是等效的，它也声明了一个指向常量字符的指针 p。在 c++ 中，const 修饰符可以放在 * 前或后，效果是一样的。

3.char * const p: 这里声明了一个指向字符的常量指针 p。这意味着 p 是一个不可变的指针，它指向的地址不能改变，但可以通过 *p 修改所指向位置的字符的值。（值可以改变）

记忆方法： 

1.const char *p 和 char const *p: 这两种声明可以记忆为“指向常量字符的指针”，其中 const 或 char const 都修饰的是指向的字符，表示指针所指向的字符是常量，不可修改。

2.char * const p: 这个声明可以记忆为“常量指针指向字符”，其中 char 修饰的是所指向的字符，而 const 修饰的是指针本身，表示指针是常量，指向地址不可改变。

16.用c++写个程序，如何判断操作系统是多少位的？ 

以下是一个简单的 C++ 程序，用于判断当前操作系统是多少位的（32位或64位）：

#include <iostream>

int main() {
    if (sizeof(void*) == 4) {
        std::cout << "This is a 32-bit operating system." << std::endl;
    } else if (sizeof(void*) == 8) {
        std::cout << "This is a 64-bit operating system." << std::endl;
    } else {
        std::cout << "Could not determine the architecture of the operating system." << std::endl;
    }
    
    return 0;
}

 这个程序通过检查 sizeof(void*) 的大小来确定操作系统的位数，因为在 32 位系统中，void* 和指针大小都是 4 字节，而在 64 位系统中，它们是 8 字节。根据 sizeof(void*) 的大小输出相应的消息。

 17.复杂指针类型

void * ( * (*fp1)(int))[10]; 
float (*(* fp2)(int,int,int))(int);
int (* ( * fp3)())[10](); 
分别表示什么意思？

1.void * ( * (*fp1)(int))[10];：fp1 是一个函数指针，该函数接受一个 int 类型的参数，并返回一个指针，指向一个包含 10 个 void * 类型元素的数组。

2.float (*(* fp2)(int,int,int))(int);：fp2 是一个函数指针，该函数接受三个 int 类型参数，然后返回一个函数指针，指向一个接受 int 类型参数并返回 float 类型的函数。

3.int (* ( * fp3)())[10]();：fp3 是一个函数指针，该函数返回一个指针，指向一个不接受参数且返回一个包含 10 个 int 类型元素的数组的函数。

18.态类中的虚函数表是compile-Time(编译时),还是Run-Time（运行时）建立的？

虚函数表（vtable）是在编译时建立的。在 C++ 中，虚函数表是用于实现多态性的一种机制，它存储了每个类的虚函数的地址。编译器在编译阶段根据类的继承关系和虚函数的定义来构建虚函数表。在运行时，通过这个虚函数表来实现动态绑定，确定调用哪个函数。

19.内存的分配方式有几种？ 

内存的分配方式通常可以分为以下几种：

1. 静态存储分配：在程序编译阶段分配内存空间，这部分内存空间在整个程序的生命周期中都是存在的，例如全局变量、静态变量等。

2. 栈式存储分配：栈内存是由系统自动分配和释放的，用于存储局部变量、函数参数、返回地址等，是一种后进先出的数据结构。

3. 堆式存储分配：堆内存是动态分配的，需要通过malloc、new等函数手动分配和释放内存。堆内存的生命周期由程序员管理。

4. 共享内存分配：多个进程可以共享同一块内存空间，这种内存分配方式常用于进程间通信。

5. 内存映射文件：将文件映射到内存空间，使得该文件可以直接在内存中读取和写入，进行高效的文件操作。

不同的内存分配方式有不同的特点和适用场景，程序员需要根据具体需求合理选择内存分配方式。

20.堆和栈有什么区别？ 

堆和栈是两种内存分配方式，它们有以下区别：

分配方式：

• 栈：栈内存由系统自动分配和释放，遵循后进先出的原则。栈内存用于存储函数的参数值、局部变量等。
• 堆：堆内存需要程序员手动分配和释放，通过malloc、new等函数进行分配，通过free、delete等函数进行释放。

内存管理：

• 栈：栈内存由系统自动管理，无需程序员手动干预。当函数执行完毕或者局部变量不再需要时，系统会自动释放栈内存。
• 堆：堆内存需要程序员手动管理，程序员需要负责分配和释放堆内存，否则可能会导致内存泄漏或者内存溢出。

内存空间大小：

• 栈：栈的内存空间通常比较小，大小由系统预先分配决定。
• 堆：堆的内存空间通常比较大，大小受限于系统的虚拟内存大小。

碎片问题：

• 栈：栈不容易产生碎片，因为栈的分配与释放遵循后进先出的规则。
• 堆：堆容易产生内存碎片，需要定期进行内存整理。

综上所述，栈比较适合存储局部变量等生命周期短、大小确定的数据，而堆适合存储动态分配、大小不确定、生命周期较长的数据。在编程中，需要根据具体需求合理选择栈和堆内存分配方式。

21.float a,b,c , 问等式 (a+b)+c==(b+a)+c 和 (a+b)+c==(a+c)+b 能否成立？ 

在 IEEE 754 浮点数标准下，浮点数可能存在精度误差，因此这两个等式不一定都成立。

对于第一个等式 (a+b)+c == (b+a)+c，由于浮点数运算的精度误差，当 a、b、c 的值接近较大的数值时，可能会存在精度问题，使得等式不成立。

对于第二个等式 (a+b)+c == (a+c)+b，同样由于浮点数运算可能存在精度误差，使得等式不一定成立。

在实际编程中，当涉及浮点数的精度要求较高时，需要谨慎处理浮点数的计算，可以考虑使用一些技巧来减小精度误差，比如确定精度范围、避免累积误差等。

22.全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的？

全局变量和局部变量是两种不同的变量类型。

区别：

全局变量：在程序的任何地方都可以访问的变量，其作用域为整个程序。在声明时，全局变量通常位于函数体外部，可以在多个函数中使用。
局部变量：只能在其被声明的特定代码块或函数内部访问的变量，其作用域仅限于所在的代码块或函数。

实现方式：

全局变量：在程序的数据段（data segment）中分配内存空间，程序从开始执行到结束时，全局变量的内存空间一直存在。
局部变量：在程序的栈帧（stack frame）中分配内存空间，只在其所在的代码块或函数执行时存在，执行完毕后会自动释放内存空间。

操作系统和编译器的知道方式：

操作系统：在编译后的可执行文件中，全局变量和局部变量的信息都会被存储。当操作系统加载可执行文件并执行时，它会根据存储的变量信息来为全局变量和局部变量分配内存空间。
编译器：在编译过程中，编译器会解析代码并生成相应的符号表。符号表包含了变量的信息，包括变量的作用域、类型、内存地址等。编译器根据符号表的信息来为全局变量和局部变量分配内存空间，并在代码中正确地引用它们。

23.在c++中，"explicit"是什么意思，"protected"是什么意思？ 

在C++中，"explicit"和"protected"是两个关键字，用于修饰类的成员和继承关系。

1.“explicit”:
"explicit"是用于修饰类构造函数的关键字。当一个构造函数被声明为"explicit"时，它将禁止隐式类型转换。这意味着在使用该构造函数创建对象时，必须显式地进行类型转换。

class MyClass {
public:
    explicit MyClass(int value) {
        // 构造函数的实现
    }
};

int main() {
    MyClass obj = 5; // 错误，禁止隐式类型转换
    MyClass obj2(5); // 正确，显式类型转换
    return 0;
}

2. protected”:

"protected"是一种访问控制修饰符，用于类的成员和继承关系。当成员或继承关系被声明为"protected"时，它们只能在该类的派生类中访问，而不能在类的外部访问。

class Base {
protected:
    int protectedVar;
};

class Derived : public Base {
public:
    void accessProtectedVar() {
        // 在派生类中可以访问protected成员
        protectedVar = 10;
    }
};

int main() {
    Base obj;
    obj.protectedVar = 10; // 错误，无法在类的外部访问protected成员
    return 0;
}

在上述示例中，派生类Derived可以访问基类Base中的protected成员，但在类的外部无法直接访问protected成员。

24.重复多次fclose一个打开过一次的FILE*fp指针会有什么结果。

重复多次调用fclose函数关闭一个已经打开过的FILE*指针fp会导致未定义的行为。这是由于fclose函数在关闭文件时会释放相关的资源和清理内部状态，包括刷新缓冲区、释放文件描述符等。如果多次调用fclose函数，则可能导致以下问题：

内存错误：重复调用fclose函数可能会导致内存错误，如访问已被释放的内存，或者修改已释放的内存。

文件描述符错误：重复调用fclose函数可能会导致文件描述符被重复关闭，进而导致错误或未定义的行为。

因此，在使用fclose函数关闭文件时，应该确保只调用一次，避免重复关闭已经关闭的文件指针。
 

25.为什么数组名作为参数，会改变数组的内容，而其他类型如int却不会改变变量的值？ 

数组名作为参数传递给函数时，会以指针的形式传递给函数。这意味着函数中使用的参数是数组的地址，而不是数组的副本。因此，对数组元素的修改在函数内外都是可见的，从而改变了数组的内容。

其他类型如int作为参数传递时，会将实参的值复制一份给形参，函数内部使用的是形参的副本。所以在函数内部对形参的修改不会影响到原始的实参变量。

这是因为数组是一种复合类型，存储多个元素的连续内存块。数组名在传递给函数时，会退化为指向数组首元素的指针。指针传递给函数是按值传递，即传递的是指针的副本，但指针仍然指向原始数组的内存空间。因此，在函数内部通过指针修改数组元素的值会直接影响到原始数组。（重点：数组没有副本机制）

26.你觉得如果不适用常量，直接在程序中填写数字或字符串，将会有什么麻烦？ 

在程序中直接填写数字或字符串而不使用常量会带来以下麻烦：

可读性差：直接在代码中写入数字或字符串会使代码变得难以理解和维护。其他开发人员在阅读代码时可能无法立即理解数字或字符串的含义和作用，增加了代码的复杂性。

代码重复：如果多次在代码中使用相同的数字或字符串，而没有使用常量进行封装，会导致代码的重复。这样一来，如果需要修改这些数字或字符串，就需要在多个地方进行修改，增加了维护的难度，并且容易出现遗漏的情况。

难以修改：如果直接在代码中写入数字或字符串，当需要修改这些值时，需要在所有使用到的地方进行手动修改，容易出现遗漏或错误。而使用常量，只需要修改常量的定义即可，可以减少出错的可能性。

可维护性差：不使用常量，直接在代码中填写数字或字符串，会使代码的可维护性变差。代码中的数字或字符串散落在各个地方，难以统一管理和修改，增加了代码的维护成本。

使用常量可以解决上述问题，将数字或字符串封装在常量中，给予其有意义的名称，提高代码的可读性和可维护性。通过修改常量的定义，可以统一修改相关的值，提高代码的可维护性和可扩展性。
 

27.为什么需要使用堆，使用堆空间的原因是什么？ 

使用堆空间的主要原因如下：

动态内存分配：堆空间允许我们在程序运行时动态地分配和释放内存。与栈空间相比，堆空间的大小不是在编译时确定的，而是在运行时根据需要进行动态调整。这对于需要根据程序运行时的情况来动态分配内存的情况非常有用，例如需要创建可变大小的数组、动态生成对象等。

对象的生存期不受限制：堆空间上分配的内存不会随着函数调用的结束而被自动释放，可以在整个程序的执行过程中保持有效。这使得我们可以在函数调用结束后继续访问和使用堆上分配的内存，而不会出现访问已释放的内存的问题。

允许多个指针引用同一块内存：堆空间的内存可以通过指针来引用，允许多个指针指向同一块内存。这对于需要在不同的上下文中共享和访问数据非常有用，可以避免进行数据的复制和传递。

支持动态数据结构：堆空间的动态分配特性使其非常适合用于实现动态数据结构，如链表、堆、树等。这些数据结构的大小和形状在运行时可能会发生变化，而堆空间可以根据需要进行动态调整。

需要注意的是，堆空间的使用需要手动进行内存的分配和释放，因此需要负责地管理内存，避免内存泄漏和悬挂指针等问题。同时，由于动态内存分配需要较大的开销，过度的使用堆空间可能会导致内存碎片化和性能问题。因此，在使用堆空间时应该谨慎考虑，合理使用动态内存分配。
 

28.const关键字，有哪些作用？ 

const关键字在C++中有以下几个作用：

        1.常量声明：const关键字用于声明常量，表示变量的值在初始化后不能再被修改。

                const int MAX_VALUE = 100;
                const float PI = 3.14;

        2.防止修改：const关键字可以用于修饰函数参数，以防止在函数内部修改参数的值。

void printValue(const int num) {
    // num = 10; // 错误，不能修改const修饰的参数
    std::cout << num << std::endl;
}

        3.类成员修饰：const关键字可以修饰类的成员变量和成员函数。

           修饰成员变量：表示该成员变量在对象创建后不能再被修改。

class MyClass {
public:
    const int MAX_VALUE = 100; // 常量成员变量
};

int main() {
    MyClass obj;
    // obj.MAX_VALUE = 200; // 错误，不能修改const修饰的成员变量
    return 0;
}

         4.修饰成员函数：表示该成员函数不会修改对象的状态。

class MyClass {
public:
    void printValue() const {
        // some code
    }
};

        5.常量指针和指针常量：const关键字可以用于声明常量指针和指针常量。

        常量指针：指针指向的地址不能修改，但可以修改指针指向的值。 

const int* ptr = # // 常量指针，指向的值不能修改

        6.指针常量：指针本身的值不能修改，但可以修改指针指向的值。

int* const ptr = # // 指针常量，指针本身的值不能修改

const关键字的作用可以帮助我们更好地管理和保护数据，提高代码的可读性和安全性。

 29.如何理解c++中的左值

左值（L-value）是C++中的一个术语，用于表示可以出现在赋值运算符左侧的表达式或标识符。

在C++中，左值是一个可以标识内存位置并允许对其进行修改的表达式。左值可以出现在赋值运算符（=）的左侧，表示将右侧的值赋给左侧的内存位置。左值可以是变量、数组元素、对象的成员等。

int num = 10; // num是左值，可以被赋值
int arr[5]; // arr是左值，可以被赋值
int* ptr = # // *ptr是左值，可以被赋值

左值具有可寻址性（addressable），即可以通过取地址运算符（&）获取其内存地址。例如，&num可以获取变量num的内存地址。

与左值相对的是右值（R-value），右值是指表达式的计算结果，它不能出现在赋值运算符的左侧。右值可以是常量、字面量、临时对象等。

int result = 2 + 3; // 2 + 3是右值，计算结果可以赋给左值result
int num = 5; // 5是右值，可以赋给左值num

需要注意的是，C++11引入了右值引用（R-value reference）的概念，允许使用&&来声明绑定到右值的引用。右值引用具有特殊的语义和用途，可以用于实现移动语义和完美转发等高级特性。

30.是不是一个父类写了一个virtual函数，如果子类覆盖他的函数不加virtual，也能实现多态？ 

是的，如果一个父类中的函数被声明为virtual，并且在子类中进行了覆盖，即使在子类中没有显式地使用virtual关键字，仍然可以实现多态。

在C++中，当一个函数在基类中被声明为virtual时，它将成为一个虚函数。虚函数通过使用动态绑定来实现多态性。当通过指针或引用调用虚函数时，根据指针或引用所指向的实际对象类型，将调用相应的覆盖函数。

class Base {
public:
    virtual void func() {
        std::cout << "Base::func() called" << std::endl;
    }
};

class Derived : public Base {
public:
    void func() override {
        std::cout << "Derived::func() called" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived(); // 使用基类指针指向派生类对象
    basePtr->func(); // 输出：Derived::func() called
    delete basePtr;
    return 0;
}

在上述示例中，基类Base中的func函数被声明为virtual，派生类Derived中进行了函数的覆盖。尽管在派生类中没有显式地使用virtual关键字，但在使用基类指针调用func函数时，实际上会调用派生类中的覆盖函数。这就是多态的体现，通过动态绑定，程序在运行时根据对象的实际类型来调用相应的函数。

31.面向对象的三个基本特征，并简单叙述之？ 

面向对象的三个基本特征是封装、继承和多态。

封装（Encapsulation）：封装是指将数据和操作数据的方法封装在类的内部，对外部隐藏内部实现细节，只暴露必要的接口供外部使用。通过封装可以实现数据的安全性和一致性，同时也提高了代码的可读性和可维护性。

继承（Inheritance）：继承是指通过已有的类派生出新的类，新的类称为子类或派生类，已有的类称为父类或基类。子类可以继承父类的属性和方法，并可以在此基础上进行扩展或修改。继承可以提高代码的复用性，减少重复的代码编写，并且可以实现多态。

多态（Polymorphism）：多态是指同一个方法可以根据调用者的不同而表现出不同的行为。具体实现多态的方式有方法重载和方法重写。方法重载是指在同一个类中定义多个方法，它们具有相同的名字但参数列表不同，根据参数的不同来选择具体执行哪个方法。方法重写是指子类重新定义父类的方法，实现自己的特定功能，但方法名、参数列表和返回值类型必须与父类的方法保持一致。多态可以提高代码的灵活性和扩展性，使得代码更容易理解和维护。

 32.重载（overload），重写(override)，重定义(redefinition)的区别是什么？

重载（Overload），重写（Override），重定义（Redefinition）是面向对象编程中三个不同的概念和操作。

重载（Overload）：重载是指在同一个类中定义多个方法，它们具有相同的名字但参数列表不同。重载可以根据不同的参数类型、参数个数或参数顺序来选择具体执行哪个方法。重载方法的返回值类型可以相同也可以不同。重载可以提供不同的方法实现，但方法名相同，从而方便调用者根据需要进行选择。重载方法之间没有继承关系，它们是在同一个类中独立存在的。

重写（Override）：重写是指子类重新定义父类的方法，实现自己的特定功能。重写的方法名、参数列表和返回值类型必须与父类的方法保持一致。重写可以在子类中对父类方法进行扩展、修改或完全重新实现。重写方法是通过继承关系实现的，子类继承了父类的方法，然后进行重写。

重定义（Redefinition）：重定义是指在同一个类中重新定义某个方法，实际上是对该方法的重新实现。重定义可以在同一个类中对某个方法进行修改或完全重新实现。重定义和重写的区别在于重定义是在同一个类中进行的，而重写是在子类中对父类方法进行重新定义。

总结：重载、重写和重定义都是在面向对象编程中用于修改或扩展方法的概念和操作。重载是在同一个类中定义多个方法，根据参数的不同进行选择；重写是子类重新定义父类的方法，实现自己的特定功能；重定义是在同一个类中重新定义某个方法，对其进行修改或重新实现。
 

33.多态的作用是什么？ 

多态的作用主要体现在以下几个方面：

灵活性和扩展性：多态允许同一个方法根据不同的对象表现出不同的行为，使得代码更加灵活和可扩展。通过多态，可以在不修改现有代码的情况下，通过增加新的子类来扩展程序的功能。

代码重用：多态可以通过继承和方法重写实现代码的重用。子类可以继承父类的方法，然后根据需要进行重写，从而实现代码的复用和共享。

统一接口：多态可以通过定义统一的接口或基类，使得不同的对象可以通过相同的接口进行操作。这样可以简化代码，提高代码的可读性和可维护性。

简化代码：多态可以减少条件判断和类型转换的使用，从而简化代码。通过多态，可以直接调用父类或接口定义的方法，而无需关注具体的子类类型。

提高可扩展性和可维护性：多态可以降低代码的耦合性，使得代码更加模块化和易于扩展。通过多态，可以将代码的变化隔离在子类中，从而提高代码的可维护性和可扩展性。

总之，多态的作用是使得代码更加灵活、可扩展和可维护，提高代码的重用性和可读性，同时降低代码的耦合性和复杂度。
 

34.当一个类A中没有 什么任何成员变量与成员函数，这是sizeof(A)的值是多少，如果不为零，请解释一下编译器为什么没让它为零。 

sizeof(A)的值在C++中至少为1，即使类A中没有任何成员变量和成员函数。
这是因为C++编译器规定，空对象的大小不能为零。这是为了确保每个对象在内存中都有独一无二的地址，以便在需要访问该对象时能够正确定位。即使一个类中没有成员变量和成员函数，它仍然需要占用至少一个字节的内存空间，以保证每个对象都有一个唯一的地址。
此外，每个对象在内存中都需要有一个地址，以便在程序中可以引用和操作该对象。所以，即使类A中没有成员变量和成员函数，sizeof(A)的值仍然不能为零。
 

35.c++里面是不是所有的动作都是main()引起的？如果不是，请举例。 

在C++中，不是所有的动作都是由main()函数引起的。以下是一些例子：

1.全局变量的初始化：在程序开始执行之前，全局变量会被自动初始化。这个初始化的过程不是由main()函数引起的。

#include <iostream>

int globalVariable = 10; // 全局变量的初始化

int main() {
    std::cout << globalVariable << std::endl;
    return 0;
}

2.静态变量的初始化：在程序开始执行之前，静态变量会被自动初始化。这个初始化的过程不是由main()函数引起的。

#include <iostream>

void function() {
    static int staticVariable = 5; // 静态变量的初始化
    std::cout << staticVariable << std::endl;
}

int main() {
    function();
    return 0;
}

3.全局对象的构造和析构：在程序开始执行之前，全局对象会被构造，而在程序结束时会被析构。这个构造和析构的过程不是由main()函数引起的。

#include <iostream>

class GlobalObject {
public:
    GlobalObject() {
        std::cout << "Constructor called" << std::endl;
    }
    
    ~GlobalObject() {
        std::cout << "Destructor called" << std::endl;
    }
};

GlobalObject globalObject; // 全局对象的构造和析构

int main() {
    std::cout << "Inside main()" << std::endl;
    return 0;
}

在上述例子中，全局变量、静态变量和全局对象的初始化、构造和析构都不是由main()函数引起的。

 36.内联函数在编译时是否做参数类型检查

在C++中，内联函数在编译时会进行参数类型检查。内联函数的定义通常放在头文件中，而调用内联函数的地方会将其内联展开，相当于将函数体直接插入到调用处。因此，编译器在展开内联函数时会对参数类型进行检查，以确保传递的参数类型与函数定义的参数类型匹配。如果传递的参数类型不匹配，编译器会发出错误或警告。

#include <iostream>

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

int main() {
    int result = add(5.5, 2); // 参数类型不匹配，编译器会发出错误或警告
    std::cout << "Result: " << result << std::endl;
    return 0;
}

在上述示例中，调用add(5.5, 2)时，传递的第一个参数的类型是double而不是int，因此编译器会发出错误或警告。这是因为内联函数在编译时会进行参数类型检查，以确保类型的匹配性。这就是inline内联函数替代#define的原因。

37.请讲一讲析构函数和虚函数的用法和作用？ 

1.析构函数（Destructor）：

• 析构函数是一个特殊的成员函数，用于在对象销毁时执行清理工作。
• 析构函数的名称与类名相同，前面加上波浪号（~）作为前缀。
• 析构函数没有返回类型，也不接受任何参数。
• 当对象被销毁时（例如，超出其作用域、delete关键字释放动态分配的对象时），析构函数会自动被调用。
• 析构函数主要用于释放对象所占用的资源，如释放动态分配的内存、关闭文件、释放网络连接等。
• 如果没有显式定义析构函数，编译器会自动生成一个默认析构函数，它执行的操作是空的。

2.虚函数（Virtual Function）：

• 虚函数是一种在基类中声明的函数，它可以在派生类中重写。
• 在基类中，通过在函数声明前加上关键字virtual来指定该函数为虚函数。
• 虚函数允许在运行时根据对象的实际类型调用适当的函数，实现多态性。
• 当使用基类指针或引用指向派生类对象并调用虚函数时，会根据实际的对象类型来决定调用哪个版本的虚函数。
• 虚函数的重写（Override）是在派生类中重新定义基类中已有的虚函数，它可以改变函数的实现细节。
• 虚函数可以被派生类中的非虚函数覆盖，但不能被派生类中的非虚函数重载。

虚函数的用法和作用：

• 多态性：通过虚函数，可以实现面向对象编程中的多态性，让不同类型的对象调用同一个函数实现不同的行为。
• 动态绑定：在运行时确定调用哪个版本的虚函数，而不是在编译时确定。
• 可替代性：派生类可以替代基类，通过指向基类的指针或引用调用虚函数，可以实现对派生类对象的访问和操作。
• 扩展性：通过在派生类中重写虚函数，可以扩展或改变基类中的操作，实现特定的功能需求。

38.new在c++中代表的是什么？ 

在C++中，new是一个运算符，用于在堆上动态分配内存来创建对象。它的作用是在运行时创建对象，并返回对象的指针。

40. .C++程序下列说法正确的有:

A、对调用的虚函数和模板类都进行迟后编译.
B、基类与子类中函数如果要构成虚函数,除了要求在基 类中用virtual 声名,而且必须名字相同且参数类型相同返回类型相同。
C、重载的类成员函数都必须要:或者返回类型不同,或者参数数目不同,或者参数序列的类型不同.
D、静态成员函数和内联函数不能是虚函数,友员函数和构造函数也不能是虚函数,但是析构函数可以是虚函数.
【标准答案】A 

延迟编译是指在程序运行时才进行编译，而不是在编译时进行编译。对于调用的虚函数和模板类的延迟编译意味着编译器在程序运行时才会实例化模板类和解析虚函数调用。

在使用虚函数的情况下，由于虚函数是在运行时通过虚函数表进行动态绑定的，因此编译器在编译时无法确定实际调用的是哪个函数。因此，虚函数的实际绑定和调用将延迟到程序运行时。

对于模板类的情况，模板类的实例化是在使用时才会进行的，因此编译器无法在编译时确定模板类的实际类型。因此，模板类的实例化也会延迟到程序运行时。

41.指针占用的大小是多少？ 

 在不同的计算机体系结构和操作系统中，指针所占用的大小可能会有所不同。一般情况下，指针的大小取决于计算机的寻址能力，即指针能够表示的内存地址范围大小。

在大多数现代计算机系统中，指针的大小通常是与计算机的字长相同的。例如，在32位系统中，指针通常占用4个字节（或32位），而在64位系统中，指针通常占用8个字节（或64位）。

需要注意的是，在某些特殊情况下，指针的大小可能会有所不同，例如在嵌入式系统或一些特定的处理器架构中。

因此，一般情况下可以认为指针占用的大小通常是与计算机的字长相同的，即4个字节或8个字节。

42.请解释c++中的继承和多态性。 

在C++中，继承和多态性是面向对象编程的重要概念，用于实现代码重用和灵活性。以下是对继承和多态性的解释：

1. 继承（Inheritance）： 继承是面向对象编程中一种类之间的关系，其中一个类（称为子类或派生类）可以继承另一个类（称为基类或父类）的属性和行为。子类继承了父类的成员变量和成员函数，并可以根据需要添加新的成员变量和函数。继承可以帮助代码重用，提高程序的可维护性和灵活性。

在C++中，继承可以通过关键字class或struct后跟冒号和基类名来实现。继承分为单继承和多继承，单继承指一个子类只有一个直接的基类，而多继承指一个子类可以有多个直接的基类。

1. 多态性（Polymorphism）： 多态性是指同一种操作或函数可以有多个不同的行为方式。在面向对象编程中，多态性允许我们使用基类指针或引用来调用派生类对象的方法，使得同一个方法调用在不同的对象上表现出不同的行为。这种行为称为动态多态性。

在C++中，多态性可以通过虚函数和运行时多态性（动态多态性）实现。当一个类的成员函数被声明为虚函数时，在子类中重写该函数，通过基类指针或引用调用虚函数时，编译器会根据对象的实际类型动态地绑定函数调用到正确的函数实现上。这也是C++中实现多态性的基础。

继承和多态性一起使用可以实现更加灵活和可扩展的代码结构，提高代码的可维护性和扩展性。

42.explicit用在哪里？有什么作用？ 

在C++中，explicit关键字通常用于声明显式构造函数，用于禁止隐式类型转换。具体来说，explicit关键字可以用在单参数的构造函数之前，以阻止编译器将单参数构造函数用于隐式类型转换。

explicit关键字的作用如下：

1. 阻止隐式类型转换：当使用explicit关键字声明构造函数时，只能以显式的方式调用该构造函数，禁止隐式类型转换。这有助于避免一些潜在的类型转换错误和意外行为。

class MyClass {
public:
    explicit MyClass(int x) {
        // 构造函数
    }
};

void func(MyClass obj) {
    // 函数
}

int main() {
    MyClass obj1 = 10; // 错误：禁止隐式类型转换
    MyClass obj2(10); // 正确：显式调用构造函数
    func(10); // 错误：禁止隐式类型转换
    return 0;
}

本质就是使得输入得方式进行规范，禁止编译器进行自动推导。