目录
1.构造函数初始化列表
有一个类A,其数据成员如下: 则构造函数中,成员变量一定要通过初始化列表来初始化的是:______。
class A { ... private: int a; public: const int b; float* &c; static const char* d; static double* e; };
A. a b c
B. b c
C. b c d e
D. b c d
E. b
F. c
答案:B
知识点:
1.1 构造函数初始化列表与函数体内初始化区别
一个类,其包含一个类类型成员,对于它的构造函数,如果在函数体内初始化,会先调用其类类型成员的默认构造函数,再调用赋值运算符;而在构造函数初始化时会直接调用它的拷贝构造函数进行初始化
函数体类初始化:
#include <iostream>
class B {
public:
B() { std::cout << "B defualt construct" << '\n'; }
B(int t) : _t(t) { std::cout << "B construct" << '\n'; }
B(const B& b) : _t(b._t) { std::cout << "B copy construct" << '\n'; }
B& operator=(const B& b) {
_t = b._t;
std::cout << "B assign operator"<< '\n';
return *this;
}
private:
int _t = 0;
};
class A {
public:
A() { std::cout << "A defualt construct" << '\n'; }
A(const B& b){
puts("---------------------");
_b = b;
std::cout << "A construct" << '\n';
}
A(const A& a) : _b(a._b) { std::cout << "A copy construct" << '\n'; }
A& operator=(const A& a) {
_b = a._b;
std::cout << "A assign operator" << '\n';
return *this;
}
private:
B _b;
};
int main() {
B b(1);
A a(b);
}
初始化列表初始化:
#include <iostream>
class B {
public:
B() { std::cout << "B defualt construct" << '\n'; }
B(int t) : _t(t) { std::cout << "B construct" << '\n'; }
B(const B& b) : _t(b._t) { std::cout << "B copy construct" << '\n'; }
B& operator=(const B& b) {
_t = b._t;
std::cout << "B assign operator"<< '\n';
return *this;
}
private:
int _t = 0;
};
class A {
public:
A() { std::cout << "A defualt construct" << '\n'; }
A(const B& b) : _b(b) {
puts("---------------------");
std::cout << "A construct" << '\n';
}
/*A(const B& b){
puts("---------------------");
_b = b;
std::cout << "A construct" << '\n';
}*/
A(const A& a) : _b(a._b) { std::cout << "A copy construct" << '\n'; }
A& operator=(const A& a) {
_b = a._b;
std::cout << "A assign operator" << '\n';
return *this;
}
private:
B _b;
};
int main() {
B b(1);
A a(b);
}
1.2 必须在初始化列表初始化的成员
• const修饰的成员变量
• 引用类型成员
• 类类型成员,且该类没有默认构造函数(由1.1内容可得)
2 引用&引用与指针的区别
2.1 引用初始化以后不能被改变,指针可以改变所指的对象
int main() {
int a = 10;
int& ref = a;
int b = 20;
ref = b;
std::cout << "a:" << a << " ref:" << ref << " b:" << b;
//output:a:20 ref:20 b:20
}
2.2 引用和指针的区别
引用和指针,下面说法不正确的是()
A. 引用和指针在声明后都有自己的内存空间
B. 引用必须在声明时初始化,而指针不用
C. 引用声明后,引用的对象不可改变,对象的值可以改变,非const指针可以随时改变指向的对象以及对象的值
D. 空值NULL不能引用,而指针可以指向NULL
答案:A
#include <iostream>
int main() {
int a = 10;
int& ref = a;
std::cout << "a:" << &a << '\n' << "ref:" << &ref << '\n';
//a:00FCF8D4 ref:00FCF8D4
int b = 10;
int* ptr = &b;
std::cout << "b:" << &b << '\n' << "ptr:" << &ptr << '\n';
//b : 00FCF8BC ptr: 00FCF8B0
return 0;
}
从定义内存上看,引用和被引用变量公用同一块空间
3 构造函数与析构函数系列题
3.1构造函数与析构函数的调用次数
1)
C++语言中,类ClassA的构造函数和析构函数的执行次数分别为()
ClassA *pclassa=new ClassA[5]; delete pclassa;
A. 5,1
B. 1,1
C. 5,5(错误)
D. 1,5
答案:A
2)
#include <iostream>
#include <string>
using namespace std;
class Test {
public:
Test(){ std::cout << this << "B defualt construct" << '\n'; }
~Test() { std::cout << this << "B destory" << '\n'; }
};
int main() {
Test t1;
puts("------------");
Test* t2;
puts("------------");
Test t3[3];
puts("------------");
Test* t4[3]; //t4是存放三个类型Test*的对象的数组
puts("------------");
Test(*t5)[3]; //t5是数组指针,指向一个存放三个类型为Test的对象的数组
puts("------------");
}
打印结果:
4 类的运算符重载
在重载一个运算符为成员函数时,其参数表中没有任何参数,这说明该运算符是 ( )。
A. 无操作数的运算符
B. 二元运算符
C. 前缀一元运算符
D. 后缀一元运算符(错误)
答案:C
例如:
前置++:T& operator++() {}
后置++:T operator++(int) {}
5 类的静态数据成员
下面有关c++静态数据成员,说法正确的是()
A. 不能在类内初始化(错误)
B. 不能被类的对象调用
C. 不能受private修饰符的作用
D. 可以直接用类名调用
答案:D :
知识点:const修饰的静态成员可以在类内初始化,所以A错误
5.1 malloc/new/new[]
malloc/calloc/realloc <----> free new <----> delete new [] <----> delete[]三者一定要匹配使用,否则会产生内存泄漏或者程序崩溃
5.2 new的实现步骤与细节
1) 对于 T*p = new T;
-第一步: 调用operator new(size_t size)申请空间(内部调用malloc循环申请)
-第二步: 调用构造函数完成对申请空间的初始化
对于 delete p;
-第一步:调用析构函数释放p指向的对象中的资源
-第二步:调用operator delete释放p所指向的空间(内部调用free)
2)对于 T*p = new T[N];
-第一步: 调用operator new[](size_t size)申请空间(内部调用operator new(size_t size))
-第二步: 调用N次T的构造函数完成对申请空间的初始化
对于 delete p;
-第一步:调用N次T的析构函数释放p指向的N个对象中的资源
-第二步:调用operator delete[]释放p所指向的空间(内部调用operator delete)
6 this指针相关题目
6.1 this指针存放在哪里?
this指针是对象调用自身方法时的第一个隐含的指针形参,一般情况由编译器通过ecx寄存器自动传递,通过下面三张图就可以自然的理解到this指针
第一张图可以看到,寄存器ecx存放的值是对象t的起始四个字节的地址
指令lea:加载有效地址(load effective address)指令就是lea,他的指令形式就是从内存读取数据到寄存器,但是实际上他没有引用内存,而是将有效地址写入到目的的操作数,就像是C语言地址操作符&一样的功能,可以获取数据的地址。
callfunc1或者func2之前会将对象t的起始四个字节的地址加载到ecx寄存器
第二张图,打印对象t的地址,调用func2,将n的值对象成员n的值改为1
调用函数,将eax寄存器push如栈,此时在监视窗口可以看到this指针和ecx的值相同,我的理解是this是函数的隐含参数,函数调用时创建,其值为eax的值,也就是最开始存放在eax中的对象的起始地址;
6.2 this可以为空吗?
答案是可以的,我们之前说到,this指针的值是对象的起始地址,如果当对象的地址为nullptr时,那么this就为空。
但是这是对this的解引用或者访问成员操作就是错误的。
函数func1调用完成没有异常,func2函数内部异常
6.3 delete this 以及 delete细节解析
如果有一个类是 myClass , 关于下面代码正确描述的是:
myClass::~myClass(){ delete this; this = NULL; }
A. 正确,我们避免了内存泄漏
B. 它会导致栈溢出
C. 无法编译通过
D. 这是不正确的,它没有释放任何成员变量。(错误)
答案:C
对于上述代码,首先它是不能被编译通过的,因为this指针本身被const修饰(对于上述例子而言this指针的类型为myClass *const), this指针本身无法被修改
如果删去`this = NULL`这一段代码,程序还是有错,我们通过下面几个例子说明⬇️
首先我们需要了解:调用delete函数之后会依次执行下面两个步骤
① 对目标调用的析构函数
② 调用operator delete释放内存
通过下面几种了解:
1)
#include <iostream>
using namespace std;
class Test {
public:
Test() {
puts("Test()");
x = 0;
ptr = new int(0);
}
~Test() {
puts("~Test() before");
delete this;
//this = nullptr; //编译错误 C2106“ = ”: 左操作数必须为左
puts("~Test() after");
}
private:
int x;
int* ptr;
};
int main() {
Test t;
}
上面这段代码执行会不断打印~Test() before,直至程序栈溢出
解释了调用operator delete之后的执行步骤,上述代码会this指针指向对象的析构函数,而析构函数中又有delete函数,导致死循环,如下图⬇️
2)
#include <iostream>
using namespace std;
class Test2 {
public:
Test2() {
ptr = new int(0);
}
~Test2() {
puts("~Test2");
delete ptr;
ptr = nullptr;
}
void deletefunc() {
delete this; //先析构,再delete this指向的堆空间(当this指向的是栈上的空间时,程序崩溃)
}
private:
int* ptr;
int x = 0;
};
int main() {
Test2* tptr = new Test2();
tptr->deletefunc();
}
通过上述代码和动画演示巩固delete的两个步骤;
如过将对象创建再栈中,上述程序又会出现bug:编译阶段不会报错,但是再运行到delete this的时候程序崩溃了,原因是对栈上的空间进行了释放
Test2 obj = Test2();
obj.deletefunc();
3)
#include <iostream>
using namespace std;
void operator delete(void* ptr) {
puts("operator delete");
}
class Test2 {
public:
Test2() {
ptr = new int(0);
}
~Test2() {
puts("~Test2");
delete ptr;
ptr = nullptr;
}
void deletefunc() {
delete this;
}
private:
int* ptr;
int x = 0;
};
int main() {
Test2* ptr = new Test2();
ptr->deletefunc();
}
调试上述代码
7. 继承与多态
几乎所有题目知识点这篇文章有覆盖,即使复习!!!
7.1 虚析构函数
下面说法正确的是()
A. 一个空类默认一定生成构造函数,拷贝构造函数,赋值操作符,取地址操作符,析构函数
B. 可以有多个析构函数
C. 析构函数可以为virtual,可以被重载(错误)
D. 类的构造函数如果都不是public访问属性,则类的实例无法创建
答案:A
析构函数可以是虚函数,但是由于只能由一个析构函数,所以自然不存在重载
知识点:重载、覆盖、隐藏的区别
7.2 纯虚函数
1)
以下关于纯虚函数的说法,正确的是()
A. 声明纯虚函数的类不能实例化
B. 声明纯虚函数的类成虚基类
C. 子类必须实现基类的纯虚函数(错误)
D. 纯虚函数必须是空函数
答案:A
具体知识点在《⌈C++⌋从无到有了解并掌握C++面向对象三大特性——封装、继承、多态》的第三章的第三节
含有(或者未经覆盖直接继承)纯虚函数的类是抽象基类(abstract base class)。抽象基类负责定义接口(因此又叫做接口类),而后续的其他类可以覆盖该接口。 (C++ Primer P540)
抽象基类(或未覆盖纯虚函数直接继承的派生类)无法实例化出对象
2)
关于抽象类和纯虚函数的描述中,错误的是
A. 纯虚函数的声明以“=0;”结束
B. 有纯虚函数的类叫抽象类,它不能用来定义对象
C. 抽象类的派生类如果不实现纯虚函数,它也是抽象类(错误答案)
D. 纯虚函数不能有函数体
答案:D 纯虚函数是可以由函数体的
#include <iostream>
using namespace std;
class A {
public:
virtual void fun() = 0 {
puts("A:virtual void fun() = 0");
}
};
class C : public A {
public:
virtual void fun() {
puts("C:virtual void fun()");
}
};
int main() {
C c;
c.fun(); //output: C:virtual void fun()
return 0;
}
7.3 继承与组合
具体知识点在《⌈C++⌋从无到有了解并掌握C++面向对象三大特性——封装、继承、多态》的第二章的第7节
面向对象设计中的继承和组合,下面说法错误的是?()
A. 继承允许我们覆盖重写父类的实现细节,父类的实现对于子类是可见的,是一种静态复用,也称为白盒复用
B. 组合的对象不需要关心各自的实现细节,之间的关系是在运行时候才确定的,是一种动态复用,也称为黑盒复用(错误)
C. 优先使用继承,而不是组合,是面向对象设计的第二原则
D. 继承可以使子类能自动继承父类的接口,但在设计模式中认为这是一种破坏了父类的封装性的表现
答案:C
7.4 继承体系中的构造与析构顺序
7.4.1 基类部分隐式销毁
具体知识点在《⌈C++⌋从无到有了解并掌握C++面向对象三大特性——封装、继承、多态》的第二章的第5.4小节
C++将父类的析构函数定义为虚函数,下列正确的是哪个()
A. 释放父类指针时能正确释放子类对象
B. 释放子类指针时能正确释放父类对象
C. 这样做是错误的
D. 以上全错
答案:A
知识点:
在析构函数题执行完成后,对象成员会被隐式销毁。类似的,对象的基类部分也是隐式销毁的。因此,和构造函数及赋值运算符不同的是,派生类析构函数只负责销毁由派生类自己分配的资源 (C++ Primer P556)
为什么先析构子类再析构父类?如果先析构父类会怎么样?
如果先析构父类,父类析构后,若子类再析构之前需要访问父类成员访问的则是一个空指针;而先析构子类则没有这个风险,因为父类不能访问子类成员
7.4.2 多继承构造顺序
由下图可知:
1)
2)
下面这段代码会打印出什么?
class A { public: A() { printf("A "); } ~A() { printf("deA "); } }; class B { public: B() { printf("B "); } ~B() { printf("deB "); } }; class C : public A, public B { public: C() { printf("C "); } ~C() { printf("deC "); } }; int main() { A* a = new C(); delete a; return 0; }
A. A B C deA
B. C A B deA
C. A B C deC(错误答案)
D. C A B deC
答案:A
8 其他于类相关的题目
8.1 空类的大小
在Windows 32位操作系统中,假设字节对齐为4,对于一个空的类A,sizeof(A)的值为()? A. 0
B. 1
C. 2
D. 4(错误)
答案:B
类大小的计算方式:与结构体大小的计算方式类似,将类中非静态成员的大小按内存对齐规则计算,并且不用计算成员函数;
特别的,空类的大小在主流的编译器中设置成了1
8.2 对const变量的修改
以下程序输出是____。
#include <iostream> using namespace std; int main(void) { const int a = 10; int * p = (int *)(&a); *p = 20; cout<<"a = "<<a<<", *p = "<<*p<<endl; return 0; }
A. 编译阶段报错运行阶段报错
B. a = 10, *p = 10
C. a = 20, *p = 20(错误)
D. a = 10, *p = 20
E. a = 20, *p = 10
答案:D
知识点:
1)编译器在编译阶段会对const修饰的变量进行优化,将其替换成变量的值
由图中的汇编代码可以看到,打印变量a时,他被直接替换成了10这个常量
volatile
C/C++ 中的 volatile 关键字和 const 对应,用来修饰变量,volatile 关键字是一种类型修饰符,用它声明的类型变量表示可以被某些编译器未知的因素更改,比如:操作系统、硬件或者其它线程等。遇到这个关键字声明的变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问。
#include <iostream>
using namespace std;
int main(void)
{
const int volatile a = 10;
int* p = (int*)(&a);
*p = 20;
cout << "a = " << a << ", *p = " << *p << endl;
return 0;
}
当用volatile修饰a之后打印结果为:
8.3 赋值运算符重载
下列关于赋值运算符“=”重载的叙述中,正确的是
A. 赋值运算符只能作为类的成员函数重载
B. 默认的赋值运算符实现了“深层复制”功能
C. 重载的赋值运算符函数有两个本类对象作为形参(错误)
D. 如果己经定义了复制拷贝构造函数,就不能重载赋值运算符
答案:A