C++ 大学课堂知识点总结
1.引用
int b;
int &a = b;//a是引用类型 定义的时候加& 表示引用 其余都是取地址
a是b别名 使用a和使用b是一样的 主要用于函数传参
引用 相当于外号 不占内存 引用是常量 定义的时候就一定要赋值 不能修改指向
指针 指针变量 存放的是地址 占内存 定义的时候并需要赋值
&a;//取地址
函数 作用 : 代码封装-->减少重复代码 划分模块 便于维护
函数调用的时候-->函数跳转(需要时间)
2.1内联
关键字 inline 内联函数--> #define M(a, b) ((a)+(b))
内联 函数 用起来和函数一样 适用于短的函数 并且常用的函数
长的函数 循环 函数调用 不适用于内联
相对于 带参宏定义的好处 参数有类型 不需要考虑优先级 直接当函数使用
2.2 重载 函数名 相同 参数不一样
C++允许函数同名 参数不一样(1.参数个数 2.类型)
a + b--> int fun(int a, int b)
double fun2(double a, double b)
-->int fun(int a, int b)
double fun(double a, double b);
一个函数名实现相近多个功能 调用函数的时候通过参数区分
仅返回值不同不构成重载
计算机通过参数类型区分调用哪个函数
2.3 缺省
定义函数的时候给参数设定默认值 调用函数的时候 这个参数可以省略
函数定义的时候能不能缺省 ? 能
函数定义的时候在参数里面写
如果函数有声明 有定义 只需在声明中缺省
缺省 只能从右往左缺省(允许全部缺省)
调用的时候 不确定调用哪个函数-->二义性(重载和缺省同时使用的时候)
4.new delete
-->new 申请 内存 malloc
--->delete 释放内存 free
申请10个int大小的空间
int *p = (int*)malloc(sizeof(int)* 10);//C语言
free(p);//C语言的内存释放
int *p = new int[10];//C++的内存申请 10个int
delete[] p;//释放内存 []放delete后面 []里面不需要加数字 delete[] p;
int *q = new int;//申请一个int
delete q;//释放内存
int *p = new int[m];//申请的时候[]里面的数字是多少个变量 m个int的大小的空间
struct node*p = new node;//申请内存
5.简单的输入输出
cin cout 输入输出 endl 换行
cin >>
cout <<
1.面向对象的思想
面向过程 1.创建界面 2.生成地图 3.贴图 4.用户点击 5.判断
以函数为中心
面向对象 用对象描述-->对象-->数据为核心
抽象 封装 继承 多态
C语言 结构体
struct student
{
//成员变量
};
C++的类
class student
{
//成员变量
//成员函数
};
对象用.对象指针 ->
public 公有 外部可以直接访问 所有人都可以用
private 私有 类的内部进行访问 但是外部不能访问
protected 受保护的 和私有类似
类中的成员变量 成员函数 默认私有
成员函数中都有一个this指针(和普通函数区别) 指针指向当前对象
区分参数和成员(如果参数名和成员名不一样 那么可以省略this指针)
类的成员函数并不是一定要在类里面定义 可以在类外定义 在类里面声明
C++ 的结构体中可以有成员函数(C语言结构体不行) private / protected / public C++结构体定义变量的时候不需要加struct关键字
struct student pointer;
区别 结构体成员默认公有 类的成员默认私有
结构体 一般只用来存放数据 类中有函数
C++结构体中也可以写函数
对象大小只和成员变量的大小有关
1.构造函数
函数给对象成员初始化-->构造函数(构造器)
构造函数 1.和类名相同 2.没有返回值类型 也没有返回值 3.调用构造的方式 对象出生自动调用(只会调用一次)
类中成员 没办法在类外访问->使用的时候赋默认值 初始化
函数名和参数-->重载 缺省
析构函数 释放资源(比如说类中的指针 申请内存 交给析构释放_)
析构函数名 ~类名 没有返回值类型, 没有参数 自动调用(对象销毁的时候调用)
new 调用构造 malloc不会
delete 调用析构 free不会
delete[] 调用所有对象的析构函数
const 常属性 只能通过初始化形参列表赋值
初始化形参列表的写法
初始化形参列表可以给const成员赋值 也可以给普通成员变量赋值
不属于某个对象 属于整个类
这个类的所有对象共用static属性成员
类--> class --->定义的变量叫做对象 作用域:全局
1.类-->提供4个默认函数
默认构造函数(没有参数的构造函数)
析构函数
拷贝构造
赋值函数
*调用时机 1)定义对象的时候 A a(A类型的对象)
2)定义对象的时候 用 = 初始化 A a = A类型的对象;
3)隐性调用 传递参数 形参拷贝实参
2.拷贝构造中 单独申请内存-->深拷贝
没有单独申请内存-->浅拷贝
浅拷贝-->两个指针指向同一个区域 释放内存会出问题
默认的拷贝构造是浅拷贝
没有写引用 有一个临时对象
对象 一般传参都会传递引用
const 常属性 const int x定义必须赋初值 赋值之后不能修改
类中的const成员变量 赋值初始化形参列表赋值
const成员函数 在成员函数后面加const 里面不能修改类成员变量的值
不能调用其他非const成员函数
const加在函数前面 修饰返回值类型
const加在函数的括号里面 修饰 参数类型
传递const引用 可以避免在函数修改实参的值
--> const int*和 int*const
const int*p 常量指针 *p的值不可以修改但指向可改变//int const *p
int*const q 指针常量 q的值能修改但q不能改指向
3.static成员(成员变量 / 成员函数)
1)修饰全局变量 不能在外部文件访问(extern指明访问访问其他cpp的变量)
2)修饰函数里面的变量 只会定义一次(静态存储区 函数调用结束先不释放)
3)修饰成员变量 static成员变量 不属于单个对象 属于整个类(赋初值 要在类外赋初值)
4)修饰成员函数 也是属于这个类 只能修改静态成员
(static修饰成员函数 没有this指针)
1.友元
数据--->私有 不能在类外访问 安全性
访问里面数据的时候-->通过函数访问 速度慢
针对常用的,需要使用类中私有成员的函数-->友元
友元 可以访问类中 的私有成员
friend 关键字 放在函数前面-->破坏数据封装性
公有成员-->所有函数都能访问
友元函数 是类的成员函数么 ? 不是
友元 外部访问私有成员的机制
通过成员函数访问私有成员-->友元提高 运行效率
缺点 破坏数据的封装性 导致程序的可维护性变差
友元类:将一个类A声明成另外一个类B的友元 这个A中所有成员函数可以访问类B的私有成员
A是B的朋友 B是不是A的朋友 ? 不是
我把你当朋友 你把我当(...自行脑补)
A是B的朋友 B是C的朋友 A是不是C的朋友 ? 不是
---> 友元类 不能传递
私有成员不能在类外访问 不影响友元
类中的函数 声明成另外一个类的友元
2.运算符重载
运算符 基本数据类型使用运算符-->在自己定义的对象之间使用运算符
PS:运算符重载不是一定要写 写了之后可以实现在自己的对象之间使用运算符操作
访问对象中的数据 1.成员函数 2.友元函数 --->a + b
operator运算符(参数)
运算符重载 函数参数个数必须和操作数个数一致
函数的实现 不要违反运算规则
优先级问题:重载时候不要改变优先级顺序
不可以创造新的运算符
双目-->推荐写友元函数 两个参数可以交换顺序
(2)关系运算符 == != > < >= <= 双目运算符
(3)逻辑运算符 && || !
(4)自增 自减(前++ 后++)
(5)位运算符
(6)赋值运算符 += -= (= 额外讲)
(7) ()[] * & ->
()--> A a; a();//调用的重载()运算符 函数调用 函数名(参数)
重载()的目的 让这个对象更像函数 仿函数 对象-->模仿函数
对象名(参数) 仿函数 调用方式和函数形式一样
1)仿函数 参数 仿函数 返回值
构造 在对象出生时调用 只会调用
仿函数 在对象出生之后调用 想调用几次就调用几次
[]--> string-->里面存了字符串 string st("hello"); 假装是数组 char*
-->st[3]-->'l'
重载[] 对象中放数组 / 指针(申请动态数组) int数组
* 里面有指针
& 返回某个成员的地址
-> 里面有结构体 / 对象 成员 返回结构体 / 对象的地址 struct
(8)new delete
new运算符 三个操作
1)operator new (可以重载的部分)主要作用 分配内存
2)调用构造函数
3)返回一个指针
1)调用析构
2)释放内存 operator delete (可以重载的部分)
* operator new() 和 operator delete() 是隐式的static成员。因此,它们无法使用this指针,也不能修改对象的值。一般不建议改写。
![](/assets/blank.gif)
![](/assets/blank.gif)
1 #include<iostream> 2 using namespace std; 3 class String 4 { 5 private: 6 char* m_data; 7 size_t length; 8 public: 9 //构造函数 10 String(const char *str=NULL) 11 { 12 if (str == NULL) 13 { 14 length = 0; 15 m_data = new char[1]; 16 *m_data = '\0'; 17 } 18 else 19 { 20 length = strlen(str); 21 m_data = new char[length + 1]; 22 strcpy(m_data, str); 23 } 24 } 25 //构析函数 26 ~String() 27 { 28 delete[] m_data; 29 length = 0; 30 } 31 //拷贝构造 32 String(const String &other) 33 { 34 length = strlen(other.m_data); 35 m_data = new char[length + 1]; 36 strcpy(m_data, other.m_data); 37 } 38 39 //获取字符串长度 40 size_t size()const 41 { 42 return length; 43 } 44 45 // [] 重载 46 char& operator[](int n)const 47 { 48 if (n >= length) 49 return m_data[length - 1]; 50 else 51 return m_data[n]; 52 } 53 // = 重载 54 String& operator=(const String &other) 55 { 56 if (this == &other) 57 return *this; 58 if (m_data) 59 delete[] m_data; 60 length = strlen(other.m_data); 61 m_data = new char[length + 1]; 62 strcpy(m_data, other.m_data); 63 return *this; 64 } 65 // + 重载 66 String operator+(const String& str)const 67 { 68 String newstr; 69 newstr.length = length + str.size(); 70 newstr.m_data = new char[newstr.length + 1]; 71 strcpy(newstr.m_data, m_data); 72 strcat(newstr.m_data, str.m_data); 73 return newstr; 74 } 75 // += 重载 76 String& operator+=(const String& str) 77 { 78 length += str.length; 79 char* newdata = new char[length + 1]; 80 strcpy(newdata, m_data); 81 strcat(newdata, str.m_data); 82 delete[] m_data; 83 m_data = newdata; 84 return *this; 85 } 86 // == 重载 87 bool operator==(const String& str)const 88 { 89 if (length != str.length) 90 return false; 91 return strcmp(m_data, str.m_data) ? false : true; 92 } 93 // >> 重载 94 friend istream& operator>>(istream& is, String& str) 95 { 96 is >> str.m_data; 97 return is; 98 } 99 // << 重载 100 friend ostream& operator<<(ostream& os, String& str) 101 { 102 os << str.m_data; 103 return os; 104 } 105 // < 重载 106 friend bool operator <(const String& s1, const String& s2) 107 { 108 if (strcmp(s1.m_data, s2.m_data) < 0) 109 return true; 110 return false; 111 } 112 // > 重载 113 friend bool operator >(const String& s1, const String& s2) 114 { 115 if (strcmp(s1.m_data, s2.m_data) > 0) 116 return true; 117 return false; 118 } 119 120 }; 121 122 class A 123 { 124 int x,*y; 125 A *p; 126 public: 127 A(int m) 128 { 129 x = m; 130 y = &x; 131 } 132 A(const A&other) 133 { 134 135 } 136 ~A() 137 { 138 139 } 140 141 A& operator&(A&other) 142 { 143 this->y = &other.x; 144 return *this; 145 } 146 friend A operator*(A&other) 147 { 148 return *(other.y); 149 } 150 A* operator->() 151 { 152 return p; 153 } 154 friend ostream&operator<<(ostream&os, A&other) 155 { 156 int q = *other.y; 157 os << q; 158 return os; 159 } 160 }; 161 int main() 162 { 163 String str1("hello"),str2("world"); 164 cout << str1 << endl << str2 << endl << str1 + str2 << endl; 165 str1 += str2; 166 cout << str1 << endl; 167 A a(1),b(2),c(3); 168 int x; 169 cout << (a&b) << endl << (*c=a) << endl; 170 return 0; 171 }
View Code
继承 从已有类中加上属性(成员变量)和方法(成员函数)定义一个新的类型
已有类 基类 / 父类 新的类 派生类 / 子类
父类派生子类 子类继承父类
2.调整
2.1访问控制
父类的成员访问权限 public private protected
继承方式
public public 不可访问 protected
private private 不可访问 private
protected protected 不可访问 protected
(子类成员的访问权限)
继承方式 默认私有
![](/assets/blank.gif)
父类的私有成员在子类中不能访问
子类继承过来的父类的成员函数去访问
private 子类继承过来不能访问
父类的成员得到隐藏
想要访问父类的同名函数 用类名
3.多继承 多个父类派生一个子类(C++有 其他语言没有)
多继承怎么写
子类拥有所有父类中所有的成员
多个父类有同名成员变量 成员函数(参数)
子类中新定义的成员和父类成员同名(隐藏)
A派生B和C B和C共同派生D D有两份来自爷爷中的成员
解决菱形继承方法-->虚继承 virtual
//解决方案 让B和C 虚继承A(两个子类都要virtual)
//实现的机制
孙子类 就一份来自祖父类的拷贝
虚继承--->解决菱形继承的问题---->孙子类
虚继承需要写在father中
B + C---->D(B(A(x, y), z), C(A(x, y), z), z) 菱形继承
虚继承-->D(B(z), C(z), A(x, y), z)// B::z C::z z
PS:这里还涉及到一个知道点----偏移量,有兴趣先自己去了解,暂时不做讲解
![](/assets/blank.gif)
![](/assets/blank.gif)
1 #include<iostream> 2 using namespace std; 3 4 class people 5 { 6 protected: 7 int age; 8 int height; 9 int ID; 10 char name[20]; 11 public: 12 people(){ cout << "调用people构造函数" << endl; } 13 ~people(){ cout << "调用people构析" << endl; } 14 }; 15 class man :virtual public people 16 { 17 protected: 18 char sex; 19 int num; 20 public: 21 man(){ cout << "调用man构造函数" << endl; } 22 ~man(){ cout << "调用man构析" << endl; } 23 }; 24 class student :virtual public people 25 { 26 protected: 27 int num; 28 int stuID; 29 public: 30 student(){ cout << "调用student构造" << endl; } 31 ~student(){ cout << "调用student构析" << endl; } 32 }; 33 34 class maleStu :public man, public student 35 { 36 int num; 37 public: 38 maleStu(){ cout << "调用maleStu构造" << endl; } 39 ~maleStu(){ cout << "调用maleStu构析" << endl; } 40 void fun() 41 { 42 43 } 44 45 }; 46 47 class maleStu1 :public student, public man 48 { 49 int num; 50 public: 51 maleStu1(){ cout << "调用maleStu构造" << endl; } 52 ~maleStu1(){ cout << "调用maleStu构析" << endl; } 53 void fun() 54 { 55 56 } 57 58 }; 59 60 int main() 61 { 62 { 63 maleStu a; 64 a.fun(); 65 } 66 cout << endl; 67 { 68 maleStu1 b; 69 b.fun(); 70 } 71 72 cin.get(); 73 return 0; 74 } 75 76 /* 77 结果: 78 多继承中 父类构造函数按照继承顺序进行调用在前的先调用在后的后调用 79 虚继承中 孙子类的构造函数调用父类和爷爷类的构造函数 顺序 爷爷类->父类1->父类2->...->孙子类 80 81 */
View Code
多态 一种形式 多种状态
想想USB接口 每种线功能不一样-->多态
一个基本保证:一个指针永远不应指向这样的对象——不能提供指针所承诺的最基本的属性
覆盖 子类重写父类的虚函数 父类的函数得到覆盖(用父类指针调用 调用的也是子类函数)
隐藏 子类重写父类的函数 父类的函数得到隐藏
//virtual void eat() = 0;// 纯虚函数
*一个有纯虚函数的类(虚类 / 抽象类 / 接口类) 没办法定义对象 只能定义指针
*如果子类继承了父类的纯虚函数 然后没有实现 那么这个子类也是虚类 不能创建对象
析构 建议写虚析构
//虚函数 类中定义了新的虚函数 类中会多出来一个指针(虚表指针)
实现多态的方式 子类通过重写 修改虚表中函数的地址
2.不能是静态成员函数
3.不能是内联函数(会处理成非内联函数) inline (PS: 类中实现的成员 默认处理成内联函数)
4.构造不能为虚函数 析构一般写虚函数
![](/assets/blank.gif)
![](/assets/blank.gif)
1 #include<iostream> 2 using namespace std; 3 class father 4 { 5 protected: 6 int x; 7 public: 8 father(); 9 virtual void fun()//虚函数 10 { 11 cout << "父类的函数" << endl; 12 } 13 virtual void eat() = 0;// 纯虚函数 14 virtual ~father(){} 15 16 }; 17 //多个函数 18 19 father::father() 20 { 21 22 } 23 24 class son :public father 25 { 26 public: 27 void fun() 28 { 29 cout << "子类的函数" << endl; 30 } 31 void eat() 32 { 33 // 34 } 35 }; 36 class son2 :public father 37 { 38 public: 39 void fun(); 40 //{ 41 // cout << "hello world" << endl; 42 //} 43 }; 44 void son2::fun() 45 { 46 cout << "hello world" << endl; 47 } 48 void fun(father *p)//形参是父类指针 实参 是子类对象的地址 49 { 50 p->fun(); 51 } 52 int main() 53 { 54 //son ss; 55 //father*p = &ss; 56 //p->fun(); 57 //cout << sizeof(ss) << endl; 58 //x.fun(); 59 //father fa; 60 son s1;//调用的是子类的构造函数 61 //son2 s2; 62 fun(&s1); 63 //fun(&s2); 64 cout << sizeof(son) << endl; 65 father *p= new son;//调用的是 子类的构造函数 66 delete p;//调用什么的析构函数 析构函数写成虚函数 67 68 69 70 71 cin.get(); 72 return 0; 73 }
View Code
cin / cout 输入输出流
文件流
ifstream 输入文件流 从文件中读取内容
ofstream 输出文件流 输出内容到文件
字节流 存二进制的方式 直接打开文件 可能会乱码
C++文件操作 对象和文件绑定
open 打开文件 close 关闭
is_open 判断是否打开成功
读取和写入
字符流 get put
字节流 read write
>> 从文件中读取数据 << 写入文件
文件指针
输入的文件流指针 seekg tellg
输出的文件流指针 seekp tellp exe-->文件
//file.open("1.txt", ios::in | ios::out | ios::binary);//打开文件 文件名+打开方式
//ios::in 读取 ios::out写入 ios::app 追加 ios::binary二进制方式打开
//file.get(ch);//从文件中读取一个字符
//file.getline(arr,100); //从文件中读取一行字符
//file.put(ch);//写入一个字符到文件
//file.put('h');
//file.write("hello world", 12);//写入文件 第一个参数char* 第二个参数代表大小
//file.read(arr, 12);//从文件中读出 第一个参数 读出来之后放的位置 第二个参数 大小
//file << "hello world";//写入文件
//file >> arr;//读取文件
//std::streamoff x = file.tellp();//返回文件指针当前位置距离文件开头的偏移量
//file.seekp(x, ios::beg);//第一个参数 偏移量 第二个参数 文件相对位置
//ios::beg 文件开始 ios::end 文件末尾 ios::cur 文件指针当前位置
输入 cin
cin >> x;
int cin.get();//得到一个字符 getchar()
istream& cin.get(char&ch);
istream& cin.get(char*arr, streamsize n);//arr是数组名 n是大小
istream& cin.get(char*arr, streamsize n, char end);//读取到这个end这个字符 提前结束
istream& cin.getline(char*arr, streamsize n);//arr是数组名 n是大小
istream& cin.getline(char*arr, streamsize n, char end);//读取到这个end这个字符 提前结束
iomanip头文件
hex / oct / dec 16进制 / 8进制 / 10进制 默认是10进制 cout << hex << 233 << endl;
2.精度控制
setprecision(4)//设置小数的位数
setiosflags(ios::fixed);//固定小数位
cout << setiosflags(ios::fixed) << setprecision(4) << 3.141592654 << endl;
cout << fixed << setprecision(5) << 3.141592654 << endl;
//用指数方式 setiosflags(ios::scientific)
3.宽度控制 左右对齐
setw(n) 设置宽度 最小输出的位数 set width
setiosflags(ios::left)//左对齐
setiosflags(ios::right)//右对齐
输入 输出
输入数据之后(炒饭)-->按了回车 进入缓冲区(上菜)---->程序读取缓冲区的内容(夹菜)
输入10个字符-->读取了5个字符 剩下5个字符留给下一次 输入缓冲区
回车作为结束-->while ((ch = getchar()) != '\n'&&ch != EOF);//清空缓冲区
printf("输入字符");//提示用户输入什么内容
scanf("%c", &ch);
![](/assets/blank.gif)
![](/assets/blank.gif)
1 #include<iostream> 2 #include<string> 3 #include<fstream> 4 using namespace std; 5 char a[1000000000]; 6 int main() 7 { 8 fstream flie; 9 flie.open("1.txt", ios::in | ios::out|ios::binary); 10 if (!flie.is_open()) 11 { 12 cout << "文件打开失败" << endl; 13 return 0; 14 } 15 16 //string a; 17 //flie >> a; 18 19 flie.seekp(0, ios::end); 20 streamoff x = flie.tellp(); 21 int y = (int)x; 22 flie.seekp(0, ios::beg); 23 flie.read(a, y); 24 for (int i = 0; i < y; i++) 25 { 26 a[i] += 5; 27 } 28 //cout << a; 29 flie.seekp(0,ios::beg); 30 flie.clear(); 31 flie.write(a, y); 32 flie.close(); 33 return 0; 34 }
简单加密
![](/assets/blank.gif)
![](/assets/blank.gif)
#include<iostream> #include<string> #include<fstream> using namespace std; char a[1000000000]; int main() {fstream flie;flie.open("1.txt", ios::in | ios::out | ios::binary);if (!flie.is_open()){cout << "文件打开失败" << endl;return 0;}//string a;//flie >> a; flie.seekp(0, ios::end);streamoff x = flie.tellp();int y = (int)x;flie.seekp(0, ios::beg);flie.read(a, y);for (int i = 0; i < y; i++){a[i] -= 5;}//cout << a;flie.seekp(0, ios::beg);flie.clear();flie.write(a, y);flie.close();return 0; }
简单解密
![](/assets/blank.gif)
![](/assets/blank.gif)
#include<iostream> #include<string> #include<fstream> using namespace std; int main() {fstream file1,file2,file3;string arr1,arr2;file1.open("1.txt", ios::in);file2.open("2.txt", ios::in);file3.open("3.txt", ios::out);if (!file1.is_open() && !file2.is_open() && !file3.is_open()){cout << "文件打开失败" << endl;return 0;}char arr[100];file1 >> arr;file3 << arr;file2 >> arr;file3 << arr;file1.close();file2.close();file3.close();return 0; }
View Code
八、异常
程序执行期间产生的问题--->(代码没问题)
try catch throw 三个关键字
catch 捕获 异常
throw 抛出异常
1.如果异常没有处理 -->调用abort()函数 中断程序
2.throw 可以在任意地方抛出异常
3.多级异常处理 里面的异常自己不能处理 继续往外丢
4.catch(...) 表示接受任意类型的异常
{
try
{
throw "hello";
}
catch (int x)
{
}
}
catch (int x){}
重载-->一个函数名 多个函数
模板 数组 链表 顺序表
1.模板分为 函数模板 类模板
template
2.函数模板
add 两个数字相加 针对仅仅是参数类型不同的函数
使用
函数模板--->传递实际类型-->模板函数
类模板--->传入实际类型--->模板类--->用模板类创建的对象
需要强调的部分
(1)类型必须指明
(2)成员函数在类外定义必须单独加上模板头
(3) 在.h里面写模板类 函数在类外定义 不要放cpp里面 直接放.h里面
重载时,函数名一样参数也一样会怎么样? 重定义
该怎么办? 命名空间
namespace summer//定义
{
//里面写函数或者变量
}
使用
1. using namespace 命名空间的名字; //最简单 但是不安全
后面直接使用函数或者变量
2. 命名空间名::函数名() //::域名解析符
指出使用哪个命名空间的函数 安全 但是最麻烦
3. 直接using std::cin; 后面直接使用cin就行 安全 比较简单
命名空间 可以嵌套
1.对象什么时候结束生命周期
作用域{} 出了作用域,对象结束生命周期
2.析构只释放构造函数中的指针
一般只用于对象内部指针
3.返回值为引用 和不为引用的区别 是否返回一个临时对象
结论 如果要进行连续操作 比如++++++a 返回引用 a = b = c = d = e 返回引用
4.父类构造析构和子类的构造析构一样么?? 不一样
子类需要写自己的构造和析构
子类调用构造函数的时候 需要先调用父类的构造及函数
子类调用析构之后 调用父类的析构函数
如果没有显性调用父类构造 会调用默认父类的构造函数
5.虚继承之后 只有一份拷贝 祖父类成员在孙子类成员中只有一份拷贝
转载于:https://www.cnblogs.com/csu-lmw/p/9215342.html
C++ 大学课堂知识点总结相关推荐
- #控制台大学课堂点名问题_你对大学生活的5大误解!看完我想静静......
开学在即,对于即将走进校园的准大学生们来说,大学都是存在于别人描述中的象牙塔,带有心向往之的美好"滤镜". 在你们正式进入大学校园之前,小编决定,顶锅盖"打假" ...
- 大学课堂的N种老师类型
前面已经说过,既然是课堂,老师当然必不可少,现在我就根据本人上大学2年来的观察总结,把课堂上的老师归为以下下几类. 一见钟情型:美貌或帅气,天然的气质,和足以颠倒众生的魅力,能使沉闷的课堂立马焕发生机 ...
- #控制台大学课堂点名问题_草率了!大学课堂点名新招数来袭,逃课的一个也没有躲过...
今天是教师节,小蚂蚁在这里祝所有的老师:教师节快乐![玫瑰] 大学时光虽然短暂,但到处充满着清新与美好.清晨的湖畔.阳光斑驳的梧桐树下.操场上的年轻情侣.图书馆勤奋苦读的学子-- 但要让我说出大学里最 ...
- 大物下(大学物理知识点回顾与典型题解析
大学物理知识回顾和典型题解 https://wenku.baidu.com/view/f93d9f10ec3a87c24028c4c3.html https://wenku.baidu.com/vie ...
- C# ASP.NET.Web大学课堂登入注册界面实验
先设计注册界面 <style>body{background-color:antiquewhite;}</style> 背景色 图像 <div><asp:La ...
- 雨课堂知识点总结(十七)
8.4 动态性能分析方法与工具 1. 以下关于Dynamic Program Analysis的说法,不正确的是__ A 根据程序执行的过程与结果,分析代码在时空性能方面所展现出的性质 B 对程序执行 ...
- 雨课堂知识点总结(七)
3.1 1.Java中的Primitive Type(int,char,boolean等)和Object Type(String,Boolean,Calendar)的差异是 前者在Stack中分配内存 ...
- 雨课堂知识点总结(十一)
3.4Object-Oriented Programming(OOP) 1.关于static和final的说法,正确的是: static类型的方法,调用时无需创建类的实例对象,可直接通过类名使用 被声 ...
- 雨课堂知识点总结(十二)
3.5 Equality 1. ADT的equals( )需要满足的三个性质是[填空1]性.[填空2]性. [填空3]性 答案: 自反性;对称性;传递性; 2. 以下针对ADT等价性的说法,不正确的是 ...
最新文章
- Java中的文件下载
- TCP/IP / 网关 IP 和 DNS 服务器 IP 为什么可以一样?
- oracle触发器中保存临时数据,Oracle使用游标触发器存储实操
- P2597 [ZJOI2012]灾难(倍增LCA+拓扑排序)
- CSS 基础入门语法
- 离婚冷静期有用吗?全国哪个省份的情侣最想结婚?大数据告诉你
- 火星人谚语系列之五:答案将由我在下一分钟给出(心想事成)
- Linux中的sed命令,使用方法之一「替换字符串中的内容 」,以及「s/ / / 」和「s/ / /g」之间的区别
- 模幂运算问题,使用朴素算法和重复-平方算法(快速幂+C#计算程序运行时间)
- 〖工具〗Ladon 8.4 Cobalt Strike插件发布
- Cisco ASA 5585防火墙ASDM配置
- fftshift详解
- 详解:什么是VXLAN?
- 操作系统 面试问题_操作系统面试问答
- Excel读写工具类
- calcite mysql_Apache Calcite 简介
- 云和恩墨进入基础软件厂商成长象限 未来发展潜力无限
- Chrome实现独立代理
- 软件工程导论——软件维护
- HDR阴影高光图像增强
热门文章
- 一堂计算机课,“星愿”第一堂电脑实操课
- presto获取上月月初和上月月末日期
- 对渗透新人的几点建议
- 互联网晚报 | 11/15 星期二 | 建行客服回应转账失败;每日优鲜全职员工仅剩55人;腾讯发布2022年三季度财报...
- 一次关于tcpdump的使用心得
- 从无到有 部署Linux项目环境
- ORB-SLAM3轨迹保存与evo评测
- 如何制作一个塔防游戏 Cocos2d-x 3.0alpha0
- 目3路考总结-海驾贴吧上的经验汇总
- 基于Python的用户管理系统实现(注册、登录)