C++类细节，面试题02-编程知识

文章目录

2. 虚函数vs纯虚函数
3. 重写vs重载vs隐藏
- 3.1. 为什么C++可以重载？
4. 类变量vs实例变量
5. 类方法及其特点
6. 空类vs空结构体
- 6.1. 八个默认函数：
- 6.2. 为什么空类占用1字节
7. const作用
- 7.1 指针常量vs常量指针vs常量指针常量
8. 接口vs抽象类
9. 浅拷贝vs深拷贝
- 9.1. 深拷贝应用场景
10. 写时拷贝

2. 虚函数vs纯虚函数

引入虚函数是为了动态绑定。
引入纯虚函数是为了派生接口，即子类仅仅只是继承函数的接口。

3. 重写vs重载vs隐藏

重写：发生继承关系中，子类重写父类的方法。
重载：发生在同一个类中，函数名相同，但参数个数或类型不同。
隐藏：子类函数屏蔽了与其同名的基类函数，有以下两种情况：
1、参数不同，基类函数被隐藏（而不是重载）。
2、参数相同，但基类函数没有virtual关键字，基类函数被隐藏（而不是重写）。

3.1. 为什么C++可以重载？

C++引入了命名空间，以及作用域，比如类作用域，命名空间作用域。
函数在编译期间，链接符号的时候，会在符号后追加一些特殊标识，比如add函数，变成add@123。

4. 类变量vs实例变量

类变量（静态变量），是类的所有实例共有的。
实例变量（对象变量），是每个实例单独拥有的。

5. 类方法及其特点

类方法（静态方法）：就是用static关键字修饰的方法
特点：类方法不能访问实例变量只能访问类变量，类方法可以由类名直接调用，也可以由实例对象调用。

6. 空类vs空结构体

空类：默认private。
空结构体：默认public。

6.1. 八个默认函数：

构造函数【A();】
析构函数【~A();】
拷贝构造函数【A (const A&);】
重载赋值运算符【A&operator = (const A&);】
重载取址运算符【A* operator& ();】
重载取址运算符const 【const A* operator& () const;】
移动构造函数（C++11) 【A(A&&);】
重载移动赋值运算符（C++11）【A& operator = (const A&&);】

6.2. 为什么空类占用1字节

因为如果对象完全不占用内存空间，空类就无法取得实例的地址，this指针失效，因此不能被实例化。而类的定义是由数据成员和成员函数组成的，在没有数据成员情况下，还可以有成员函数，因此仍然需要实例化。

7. const作用

限定变量不可修改。
限定成员函数不可修改数据成员（后置const）。
成员函数的返回值类型是const，则返回值不是左值（前置const）。
用const对函数的参数修饰，表面是输入参数，在函数内不可写。

7.1 指针常量vs常量指针vs常量指针常量

指针常量，即指针本身是常量，所以指针的值（内存地址）不能改变，示例如下。

    int a = 10, b = 20;int* const p= &a;p = &b;  //错误，指针存放的内存地址不可变*p= 100; //正确，内存地址存放的内容可以改变

常量指针，即指向常量的指针，不能通过指针修改指向的内容，示例如下。

    const int a = 10;int b = 20;const int* p = &a;p = &b; //正确， 指针存放的内存地址可变*p = 100; //错误，指针指向的内容不可变b = 100; //正确，可以通过原来的声明修改

常量指针常量，即指向常量的指针本身也是常量，不能通过指针修改指向的值，指针的值不能改变，示例如下。

    const int a = 10;int b = 20;const int* const p = &a;p = &b; //错误， 指针存放的内存地址不可变*p = 100; //错误，指针指向的内容不可变

8. 接口vs抽象类

纯虚函数是在基类中声明但没有定义的虚函数，要求子类必须提供实现。
抽象类：带有纯虚函数的类。
抽象类作用：为了扩展和重用。
接口：没有数据成员；成员函数都是公有的、都是纯虚函数，虚析构函数除外；是完全抽象的类。
接口作用：只提供了一种规范，实现接口的类必须实现接口中的所有方法。
代码如下。

// ConsoleApplication5.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#include<iostream>
using namespace std;//抽象类
class Shape 
{
protected: //数据成员：价格和面积double price; double area; public://构造函数Shape() :price(100),area(0) {} //虚析构函数virtual ~Shape() { printf("%s\n", "Delete shape"); } //纯虚函数：获取图形描述和获取价格virtual void getDescription() = 0; virtual void getPrice() = 0;
};//接口
class Draw
{
public://虚析构函数virtual ~Draw() { printf("%s\n", "Delete Draw"); }//纯虚函数：输出图形周长virtual void drawLen() = 0;  
};//具体类
class Circle : public Shape,public Draw
{
private:double radius; public:Circle(double r) : radius(r) { area = 3.14 * radius * radius; price = 100 + area * 6; }~Circle() { printf("%s%f\n", "Delete circle with radius ",radius); }void getDescription() { printf("%s%f\n", "Circle with radius ",radius);}void getPrice(){ printf("%s%f%s%f\n", "Circle with area ", area," price ",price); }void drawLen() { printf("%s%f\n", "Circle with len ", 2 * 3.14 * radius); }
};int main() {Circle c(5.0);Shape* s = &c; //基类（Shape）指针指向子类（Circle）对象s->getDescription();s->getPrice();Draw* d = &c;  //基类（Draw）指针指向子类（Circle）对象d->drawLen();_CrtDumpMemoryLeaks();return 0;
}

程序执行结果，如下图。

在这里插入图片描述

9. 浅拷贝vs深拷贝

浅拷贝只是将指针拷贝，指向同一块内存。
深拷贝是直接将内存拷贝一份。

9.1. 深拷贝应用场景

**【注意】**当类成员变量是指针，为它动态分配内存时，有以下两种bug情况：
1、若使用默认的重载赋值运算符进行浅拷贝，即a和b指向同一内存，但b曾指向的内存不会被删除，造成内存泄漏；若一方离开了它的生存空间，使用析构函数释放资源，另一方会变成悬空指针，导致未定义行为；同时当另一方调用析构函数时，会因重复释放同一堆空间而触发中断。
2、若使用默认的拷贝构造函数进行浅拷贝，会重复释放同一内存。
所以，为避免这两种bug情况，需要进行深拷贝。
修改一个对象不会影响到另一个对象时，进行深拷贝以确保每个对象都有自己独立的数据副本。