C++高频知识点（四）

文章目录

[16. 虚基类要解决什么问题？](#16. 虚基类要解决什么问题？)
[17. C++中如何进行类型转换操作？列举并解释四种类型转换方式。](#17. C++中如何进行类型转换操作？列举并解释四种类型转换方式。)
[18. 什么是函数重载？如何进行函数重载？](#18. 什么是函数重载？如何进行函数重载？)
[19. 解释C++中的友元函数和友元类，并解释其使用场景。](#19. 解释C++中的友元函数和友元类，并解释其使用场景。)
- 友元函数
- 友元类
[20. 请解释C++中的静态断言（Static Assertion）是什么，如何使用它？](#20. 请解释C++中的静态断言（Static Assertion）是什么，如何使用它？)

16. 虚基类要解决什么问题？

C++中的虚基类（virtual base class）主要用于解决多重继承中的菱形继承（diamond inheritance）或称为钻石继承问题。在菱形继承中，一个类从两个或多个类中继承，而这些类又从一个共同的基类继承。如果没有使用虚基类，那么最终的派生类会包含多个基类的副本，这可能导致数据冗余和意外行为。

以下是一个菱形继承的示例：

cpp 复制代码

class Base {  
public:  
    int x;  
};  
  
class Derived1 : public Base {  
    // ...  
};  
  
class Derived2 : public Base {  
    // ...  
};  
  
class FinalDerived : public Derived1, public Derived2 {  
    // ...  
};

bash 复制代码

        Base
       /    \
 Derived1  Derived2
       \    /
     FinalDerived

为了解决这个问题，我们可以将基类声明为虚基类：

bash 复制代码

          Base
        /      \
Derived1(virtual) Derived2(virtual)
        \      /
      FinalDerived

cpp 复制代码

class Base {  
public:  
    int x;  
};  
  
class Derived1 : virtual public Base {  
    // ...  
};  
  
class Derived2 : virtual public Base {  
    // ...  
};  
  
class FinalDerived : public Derived1, public Derived2 {  
    // ...  
};

现在，FinalDerived的对象只包含一个Base类的成员x的副本。这是因为Derived1和Derived2都是虚拟继承自Base，所以它们共享同一个Base的子对象。

17. C++中如何进行类型转换操作？列举并解释四种类型转换方式。

在C++中，类型转换操作允许程序员将一个数据类型的值转换为另一个数据类型的值。以下是四种主要的类型转换方式，以及它们的解释：

静态类型转换（Static Cast）
静态类型转换是最常用的类型转换方式，它用于基础数据类型之间的转换，以及从派生类到基类的转换（安全的向下转型） 。它不会执行运行时检查，因此如果转换是不安全的，可能会导致未定义的行为。
示例：

cpp 复制代码

double d = 3.14;  
int i = static_cast<int>(d); // 将double类型的d转换为int类型的i

动态类型转换（Dynamic Cast）
动态类型转换主要用于类层次结构中，**安全地将基类指针或引用转换为派生类指针或引用。**如果转换是无效的（即基类指针不指向派生类对象），则动态类型转换将返回空指针（对于指针）或抛出异常（对于引用）。动态类型转换只在支持RTTI（运行时类型识别）的类（即包含至少一个虚函数的类）上有效。
示例：

cpp 复制代码

class Base {};  
class Derived : public Base {};  
  
Base* b = new Derived();  
Derived* d = dynamic_cast<Derived*>(b); // 如果b确实指向Derived对象，则转换成功

常量类型转换（Const Cast）
常量类型转换用于去除或添加const或volatile限定符。它主要用于将指向const对象的指针或引用转换为指向非const对象的指针或引用 （注意：这样做可能会破坏const语义，导致程序出错）。
示例：

cpp 复制代码

const int* pc = &i;  
int* p = const_cast<int*>(pc); // 去除const限定符

重新解释类型转换（Reinterpret Cast）
重新解释类型转换提供了最低级别的转换，它**可以把任何指针类型转换为任何其他指针类型，把任何整数类型转换为任何指针类型，或者把任何指针类型转换为任何整数类型。**这种转换非常危险，因为它不进行任何类型检查，完全依赖于程序员知道自己在做什么。
示例：

cpp 复制代码

int* i = new int(10);  
char* c = reinterpret_cast<char*>(i); // 将int*转换为char*

18. 什么是函数重载？如何进行函数重载？

在C++中，函数重载是一种功能，它允许程序员在同一作用域内定义多个同名函数，但它们的参数列表（参数类型、参数数量或参数顺序）必须不同。编译器根据传递给函数的参数类型、数量和顺序来确定调用哪个函数。

以下是一个简单的函数重载示例：

cpp 复制代码

#include <iostream>  
  
// 第一个重载函数，接受一个整数参数  
void print(int x) {  
    std::cout << "Integer: " << x << std::endl;  
}  
  
// 第二个重载函数，接受一个浮点数参数  
void print(double x) {  
    std::cout << "Double: " << x << std::endl;  
}  
  
// 第三个重载函数，接受两个整数参数  
void print(int x, int y) {  
    std::cout << "Two integers: " << x << " and " << y << std::endl;  
}  
  
int main() {  
    print(5);        // 调用第一个重载函数  
    print(5.5);      // 调用第二个重载函数  
    print(5, 10);    // 调用第三个重载函数  
    return 0;  
}

需要注意的是，函数重载只与函数名和参数列表有关，与函数的返回类型、函数所在的类或其他任何东西都无关。

19. 解释C++中的友元函数和友元类，并解释其使用场景。

在C++中，友元函数和友元类是两个特殊的概念，它们打破了数据封装的原则，允许非成员函数或类直接访问另一个类的私有或保护成员。

友元函数

定义：
一个函数如果不是某个类的成员函数，但它需要访问该类的私有或保护成员，那么可以将该函数声明为该类的友元函数。

语法：

在类定义中，使用 friend 关键字来声明友元函数。

cpp 复制代码

class MyClass {  
private:  
    int privateVar;  
  
public:  
    MyClass(int var) : privateVar(var) {}  
  
    // 声明友元函数  
    friend void friendFunction(MyClass& obj);  
};  
  
// 定义友元函数  
void friendFunction(MyClass& obj) {  
    std::cout << obj.privateVar << std::endl;  // 可以访问私有成员  
}

使用场景：

运算符重载：有时我们需要为类重载一些运算符，如 +、-、<< 等。由于这些运算符不是类的成员函数，但又需要访问类的私有成员，因此可以将它们声明为类的友元函数。
两个类需要共享数据：当两个类之间需要紧密合作，并且需要共享一些私有数据时，可以将一个类的成员函数声明为另一个类的友元函数。

友元类

定义：

如果一个类需要访问另一个类的私有或保护成员，那么可以将这个类声明为另一个类的友元类。

语法：

在类定义中，使用 friend 关键字来声明友元类。

cpp 复制代码

class MyClass2;  // 前置声明  
  
class MyClass1 {  
private:  
    int privateVar;  
  
public:  
    MyClass1(int var) : privateVar(var) {}  
  
    // 声明MyClass2为友元类  
    friend class MyClass2;  
};  
  
class MyClass2 {  
public:  
    void accessPrivateVar(MyClass1& obj) {  
        std::cout << obj.privateVar << std::endl;  // 可以访问MyClass1的私有成员  
    }  
};

20. 请解释C++中的静态断言（Static Assertion）是什么，如何使用它？

在C++中，静态断言（Static Assertion）是一种在编译时检查条件是否满足的机制。如果条件不满足，编译器会发出错误消息并停止编译。这种机制对于在编译时捕捉一些常见的编程错误非常有用。

C++11标准引入了static_assert关键字来实现静态断言。static_assert接受两个参数：第一个参数是一个布尔表达式，第二个参数（可选）是一个字符串字面量，用于在断言失败时输出错误消息。

以下是使用static_assert的基本语法：

cpp 复制代码

static_assert(condition, "error message if condition is false");

其中condition是一个在编译时就能计算出结果的布尔表达式，"error message if condition is false"是当condition为假时，编译器输出的错误消息。

以下是一个简单的例子，演示了如何在C++中使用static_assert：

cpp 复制代码

#include <iostream>  
  
int main() {  
    const int arraySize = 5;  
    static_assert(arraySize > 0, "Array size must be greater than zero!");  
  
    // 如果arraySize小于或等于0，上面的static_assert会导致编译错误  
  
    // 假设我们有一个数组，这里只是示意  
    int myArray[arraySize];  
  
    // ... 数组的其他操作 ...  
  
    return 0;  
}

之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力！！！↖(▔▽▔)↗感谢支持！