建设银行网站总是崩溃,随州网络科技有限公司,wordpress内容模型,儋州网站建设制作目录 1.构造函数初始化列表 1.1 构造函数初始化列表与函数体内初始化区别 1.2 必须在初始化列表初始化的成员 2 引用引用与指针的区别 2.1 引用初始化以后不能被改变#xff0c;指针可以改变所指的对象 2.2 引用和指针的区别 3 构造函数与析构函数系列题 3.1构造函数与析… 目录 1.构造函数初始化列表 1.1 构造函数初始化列表与函数体内初始化区别 1.2 必须在初始化列表初始化的成员 2 引用引用与指针的区别 2.1 引用初始化以后不能被改变指针可以改变所指的对象 2.2 引用和指针的区别 3 构造函数与析构函数系列题 3.1构造函数与析构函数的调用次数 4 类的运算符重载 5 类的静态数据成员 5.1 malloc/new/new[] 5.2 new的实现步骤与细节 6 this指针相关题目 6.1 this可以为空吗 6.2 this指针存放在哪里 6.3 delete this 7 其他于类相关的题目 7.1 空类的大小 7.2 对const变量的修改 volatile 7.3 赋值运算符重载 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 iostreamclass 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 iostreamclass 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 iostreamint main() {int a 10;int ref a;std::cout a: a \n ref: ref \n;//a:00FCF8D4 ref:00FCF8D4int b 10;int* ptr b;std::cout b: b \n ptr: ptr \n;//b : 00FCF8BC ptr: 00FCF8B0return 0;
} 从定义内存上看引用和被引用变量公用同一块空间
3 构造函数与析构函数系列题
3.1构造函数与析构函数的调用次数
1 C语言中类ClassA的构造函数和析构函数的执行次数分别为 ClassA *pclassanew 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可以为空吗
6.2 this指针存放在哪里
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 空类的大小 在Windows 32位操作系统中假设字节对齐为4对于一个空的类Asizeof(A)的值为 A. 0 B. 1 C. 2 D. 4错误 答案B
类大小的计算方式与结构体大小的计算方式类似将类中非静态成员的大小按内存对齐规则计算并且不用计算成员函数
特别的空类的大小在主流的编译器中设置成了1
7.2 对const变量的修改 以下程序输出是____。 #include iostream
using namespace std;
int main(void)
{const int a 10;int * p (int *)(a);*p 20;couta a, *p *pendl;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之后打印结果为 7.3 赋值运算符重载 下列关于赋值运算符“”重载的叙述中正确的是 A. 赋值运算符只能作为类的成员函数重载 B. 默认的赋值运算符实现了“深层复制”功能 C. 重载的赋值运算符函数有两个本类对象作为形参错误 D. 如果己经定义了复制拷贝构造函数就不能重载赋值运算符 答案A
