1. C++语言基础
1.1 函数
C++新增:多态
-
函数重载( overload )
-
函数重写(覆写,overrride)
编译器会根据实参的类型来⾃动确定调⽤哪个重载函数
C++新增:内联函数
修饰关键字:inline
作用:编译时直接将函数替换为一堆代码,减少函数调用带来的开销。
比#define安全
成员函数默认内联,即使不写inline;外部函数必须加inline才能内联。
内存分配管理
每一个函数在栈空间上都有一段栈帧,保存这当前函数所需的变量等。当函数出栈时,这些成员也随之销毁。
1.2 const修饰符
const修饰的对象、变量,在运行过程中不能修改其值。
const int a = 1;
a = 2; // 错误!
// 会报错:error: assignment of read-only variable 'a'
注意:常量必须在声明时被初始化 const int a; // 错误!
关于const可修改的练习:
例1
int main() {
const int a = 1;
int* add = &a; // 这一句有语法问题:invalid conversion from 'const int*' to 'int*'
*add = 2;
return 0;
}
编译器在做隐式转换的时候不会添加或删除const修饰,如果类型不匹配会报语法错误。
正确做法:使用强制类型转换,消除语法问题
int main() {
const int a = 1;
int* add = (int*)&a; // 正确
*add = 2;
return 0;
}
编译器不会自作主张修改const修饰,因为可能有潜在风险,但是如果人为地强制转化,说明是程序员告诉编译器:“就这么干,我说的!“。编译器就会很放心地让程序员来承担责任,不会报错 /doge
注意:这里a为局部变量,即使被const修饰,也保存在栈上(假设没有常量折叠)。如果换做全局变量,被const修饰后存储在常量区中,为只读属性,没有办法修改的。
例2:指针变量也是变量,所以可用const修饰
常量指针
int main() {
char array[] = {'a', 'b', 'c', 'd', '\0'};
char* const name = array; // 注意这里的 * 和 const的前后位置
name[0] = 'H'; // 正确
name = (char*)"Hi"; // 错误! assignment of read-only variable 'name'
return 0;
}
指向常量的指针
int main() {
char array[] = {'a', 'b', 'c', 'd', '\0'};
char const* name = array; // 注意这里的 * 和 const的前后位置
name[0] = 'H'; // 错误!
name = (char*)"Hi"; // 正确
return 0;
}
这里可以这样子去记忆:const负责在他左边的东西,如果左边是char*,说明地址是常量,如果左边是char,说明字符是常量。
1.3 动态内存分配
常规的静态分配内存:int a[10] = {0};
数组a在编译的时候就被分配了固定大小的内存。
int n = 10;
int b[x]; // 对于多数编译器是不允许的,即使允许也会有⻛险,如多线程编程
而使用动态定义变量更灵活
int n = 10;
int* b = new int[n]();
注意:最后记得delete
1.4 作用域运算符::
-
使用类的静态成员
-
解除被隐藏全局函数或变量
int num = 1; // 全局变量
main() {
int num = 2; // 局部变量
cout << num << endl; // 显示局部变量
cout << ::num << endl; // 显示全局变量
}
2. 类和对象
注意点:
-
(C++11之前)在类体中不允许对数据成员进行初始化
class A {
int a = 0; // 在一些老版本的编译环境上会出错
};
-
类中的成员不能是自身类的对象
否则会导致无限递归,最终栈溢出,因此会报编译错误。
但是可以放自身类的指针或引用。
-
若类A中含有成员类B,则类B需要提前声明
-
数据成员不能用auto、register、extern修饰;成员函数不能用extern修饰
2.1 拷贝构造函数
注意点:
-
形参必须是对象的引用,&不能省略,否则会向上文所述的无限递归。
-
要特别注意浅拷贝的问题
举个例子
class A {
char* name;
~A() { delete[] name; }
};
-
当调用拷贝构造函数的时候,编译器会无脑复制一份数据到新对象,此时两个对象中name指向同一个地址,当两个类调用析构函数时,name会被delete两次,第二次会出错。
这种情况必须自己写拷贝构造函数。
-
对象作为参数传递时,用引用或者指针好一点,可以避免一次拷贝构造,减少开销
2.2 静态成员
作用:为了解决同类对象间的数据共享问题,实际就是共享变量
静态成员在整个内存中只有一份,位于静态区。
在编译器遇到初始化语句时,就为其分配空间。
两种初始化方法:
-
在类内初始化:必须加static修饰符
-
在类内声明,要加static;在类外初始化,不加static
静态成员函数只能访问静态成员,因为非静态成员有对象才存在;相反,非静态成员函数可任意访问静态、非静态成员。在⼀般的成员函数中都隐含有⼀个this指针,⽤来指向对象自身,而在静态成员函数中没有this指针,这是无法访问非静态成员的技术原因。但是若向静态函数中传入对象,则可以访问对象中的非静态成员。
2.3 友元
允许⼀个类授权另⼀个类的对象(友元类)、某个成员函数(友元成员)或外部函数(友元函数)访问其对象的非公有成员,而不允许整个程序访问。是类的封装性与执行效率的折中。
Java保留了静态成员,舍弃了友元机制。
2.4 对象嵌套
比如类A中有成员变量类B,则在实例化A的时候,先调用B的构造函数,再调用A的构造函数(先里后外)
另外,在A的构造函数中,推荐使用构造函数初始化列表,来初始化B。
3. 派生类
重定义(隐藏)redefining:派生类中重新定义基类成员,包括数据成员、成员函数,可参考重写(覆盖)overload:是重定义,但使用虚函数,实现了多态在java中两者无区别
派生类重新定义了print,则派生类中有两个print,但隐藏了继承来的print——用派生类对象a调用print,即a.print(),调用的是重新定义的,除非a.person::print();或者用基类指针指向a,用指针调用print。如果是重写,则根据虚表直接找到重写的print。
3.1 派生方式
这里比较绕,分三步说明
1)权限变化
-
公有派生中,权限不变。公有 -> 公有,私有 -> 私有,保护 -> 保护
-
私有派生中,all -> 私有
2)类内访问权限
-
基类的公有和保护成员都能够被派生类的成员访问
-
基类的私有成员不能被派生类成员直接访问,但可以通过基类的公有成员函数间接访问,比如基类的get、set
3)类外访问权限
指的是实例化派生类后,能否通过a.print()的方式访问类内成员
从类外看,派生类和基类是融为一体的,就当作一个普通的类操作,所以当然是私有不能访问,公有可以访问,而具体是私有还是公有见 1)中分析
综上所述,派生方式只改变类外访问权限
3.2 派生类构造、析构函数
派生类不继承构造函数,因为不符合构造方法的命名规则。但调用派生类构造函数时,编译器也要调用基类构造函数,这不是真正意义上的继承。析构函数也是类似。但基类析构函数可以在子类中用基类名显式调用
注意:C++基类的析构函数一般定义为虚函数,防止内存泄漏
执行顺序
创建派生类对象:(1)先执行基类的构造函数(2)执行派生类的构造函数
销毁派生类对象时,相反
如何传参
-
如果基类的构造函数没有参数,或者没有显式地定义构造函数的时候,派生类构造函数不必考虑向基类构造函数传递参数,甚至可以不定义构造函数
-
当基类中带有参数的构造函数的时候,派生类必须定义构造函数,且使用初始化列表传递参数
3.3 重新定义
3.4 多重继承
派生类有多个基类,派生方式可以各不相同
构造顺序
A 基类
/ \
B C
\ /
D
构造顺序为 ABACD
但是多继承可能有模糊性(菱形继承的二义性) 。此外,从不同类继承同名成员,也会出现歧义性
3.5 虚拟继承
class 派生类名 : virtual 派生方式 基类名{
// .....
};
编译器保证从虚基类中继承的成员只有一个拷贝,避免模糊性
一些语法规定
A 基类
/ \
B C BC继承A时需要虚继承
\ /
D D不需要虚继承
也就是说,虚继承可以作用于一分为二的继承,避免基类成员也一分为二。而在合二为一的情况下,虚继承没有用
在D的构造函数中,需要用参数化列表调用ABC的构造函数,即在直接继承BC基础上,加一个虚基类(祖先)的构造函数。因此,BC在继承A的时候,必须是公有继承,不然D无法调用A的构造函数,因此虚继承必须是公有继承。
构造顺序
上图调用顺序为ABCD,虚基类(祖先)第一个调用,并且只会调用一次,从而保证其成员只会被初始化一次。当然,如果虚基类还有父类,那应该按正常流程先调用父类,再子类。然后,虚继承的类先构造,非虚继承的类后构造
即:
-
虚基类或非虚基类的祖先的构造函数
-
任何虚继承基类的构造函数按照它们被继承的顺序构造
-
任何非虚继承基类的构造函数按照它们被继承的顺序构造
-
对象成员的构造函数
-
派生类自己的构造函数
析构顺序相反
构造顺序 例1
A
|
B (C) D (E)
\ | | /
F
其中F虚继承于CE,用括号表示,并包含一个M类成员
class F : public B, virtual public C, public D, virtual public E {
// ...
M mem1;
}
则构造顺序为:CEABDMF
构造顺序 例2
class A {
public:
int a;
A() { a = 10; }
};
class A1 : virtual public A {
public:
A1() { a++; }
};
class A2 : virtual public A {
public:
A2() { a++; }
};
class B : public A1, public A2 {
public:
B() { a++; }
void print() { cout << a << endl; }
};
int main() {
B b;
b.print();
return 0;
}
结果输出:13
补充
大部分编译器都提供了查看C++代码中类内存分布的工具,比如vs。参考
-
虚基类的直接子类(Veichle_Road、Veichle_Water)存放指向虚基类表的指针,以及自己新定义成员。
-
后续子类(Amphicar)继承了两个父类的成员,包括虚基类表指针,并存放了虚基类成员(weight)的一个拷贝。
4. 多态性(polymorphism)
4.1 编译多态和运行多态
-
重载(Overload):不同函数使用同一个函数名,即同样的接口实现不同的操作
-
重写(Override):对虚函数的重新定义,即有继承关系的 不同类对象 对同一消息作出不同响应
-
重新定义(Redefining):在派生类中定义一个新的
-
运算符重载
-
模板
联编
-
静态联编:在编译阶段进行联编,速度快、效率高,但不灵活
-
动态联编:在程序运行阶段进行联编,即直到程序运行时在确定调用哪个函数
在C++中:函数重载(含运算符重载、重新定义、模版)是通过静态联编实现的虚函数多态性(重写)是通过动态联编来实现的,使用虚函数表在运行时实现
举个例子
用来体会一下静态联编
class Point {
public:
Point(double i, double j) {
x = i;
y = j;
}
double Area() const { return 0.0; } //
private:
double x, y;
};
class Rectangle : public Point {
public:
Rectangle(double i, double j, double k, double l);
double Area() const { return w * h; } // 在派生类中重新定义
private:
double w, h;
};
Rectangle::Rectangle(double i, double j, double k, double l) : Point(i, j) {
w = k;
h = l;
}
void fun(Point& s) { // 外部函数
cout << s.Area() << endl;
}
void main() {
Rectangle rec(3.0, 5.2, 15.0, 25.0);
fun(rec);
rec.Area();
}
注意fun函数的形参为Point&,即基类引用,因此会窄化,fun始终调用基类的Area()。若参数改为:Rectangle &s,也同样只能调用Rectangle中的Area()
4.2 函数重载
不同函数使用同一个函数名,由编译器来选择具体由哪个函数来执行
4.3 运算符重载
一般用于操作类,比如两个自定义类的 “+” 运算
显然,重载的运算符函数必须要能访问类中元素,因此运算符重载 要么是成员函数,要么是外部友元函数。如果用成员函数,那形参只有一个,如果是友元函数,形参有两个。特别的,( )
、[ ]
、->
、=
,必须用成员函数实现运算符重载,<<(输出)
必须用友元函数实现运算符重载。
有一些运算符是不能重载的,共5个:.
.*
::
?:(三目运算符)
sizeof
对于[]、<<,都是两目,但区别是第一个参数是本类对象或其它类对象,所以采用不同实现方法,原因:
-
如果用成员函数实现,类的this指针会被绑定到运算符的左侧对象,防止出现异常的写法。这是与this的背后实现有关:比如
a.f()
,编译器先用this指向对象a,然后调用函数f,函数中访问数据成员时,编译器通过this到对象中找。对于a[i]的重载,[]是函数,所以仍遵循上述原理。 -
如果是友元,则没有this指针,双目运算符左右对象无限制,比如第一形参是整型(下标),第二形参是对象。可能导致:3[a] 。可参考
-
每个非静态成员函数都有一个隐式参数(编译器编译器编译时自动添加的),这个参数就是成员函数中this指针的来源,并且是第一个参数。比如:
void A::f() {}
,实际上是:void A::f(A *const this) {}
编译器在编译时会自动传递参数,使得成员函数可以访问对象的数据成员。因为数据成员分配在对象中,而成员函数本类对象共用,分配在别的地方。<<
运算符重载函数要求第一个参数必须是std::ostream &
,所以必须是非成员函数。但不一定非得是友元,除非访问私有成员
关于编译优化
在值返回的时候会有所区别
Integer operator+(const Integer& a) { // 情况1:返回局部对象
return Integer(val + a.val);
}
Integer operator+(const int x) { // 情况2:返回局部对象
Integer tmp;
tmp.val += x;
return tmp;
}
Integer operator+(const char x) { // 情况3:用*this返回
return *this;
}
Integer operator-(const Integer x) { // 情况4:返回形参对象
return x;
}
在上述12两种返回局部对象的情况时,按理来说,应该是在return时创建一个匿名对象,再调用拷贝构造函数将其赋值给调用运算符的左值。而编译器会对此优化,不需要拷贝构造。
因此,上述四种情况分别会
-
一次普通构造
-
一次普通构造
-
一次拷贝构造
-
两次拷贝构造 (形参到实参也要一次)
增量运算符的重载
Integer& operator++( ); //前缀增量运算符
Integer operator++(int); //后缀增量运算符
前缀与后缀在调用时其实形式一样,为了在调用时能够区分前、后缀,c++后来(开始时前后缀无区分)规定:后缀函数加一个没有实际意义的int参数,这样编译器在判断出前后缀时,就知道调用哪一个了。在调用后缀函数时,自动传给参数int的值是0,所以该参数的变量名都可以省略
前缀按语义可连接,后缀不允许。此外后缀要先返回后加加,故返回对象。非要返回引用当然也可以,但会造成连续加加,不符合语义。
类型转换运算符重载
通过构造函数进行(简单类型 -> 类对象)
通过类型转换运算符重载进行(类对象-> 简单类型)
如operator int();
Integer::operator int() {
cout << “Type changed to int” << endl;
return value; // 没返回类型,但要返回
}
注意:没有返回类型、参数
-
没有返回类型,因为强制转换为int说明int就是返回类型,再写一遍多此一举
-
没有参数,因为强制转换为单目运算符,加之用成员函数实现
赋值运算符重载
如果不重载,编译器会默认一个,其默认行为是复制对象的数据成员,就和默认拷贝构造函数一样,但这会导致浅拷贝
赋值运算符重载不能继承。实际是可继承,但因为派生类没定义赋值重载,则编译器默认一个,隐藏了继承来的
4.4 虚函数
动态联编实现的运行时多态
通常用基类指针(或引用)指向公有派生类对象。必须是公有派生,如果私有派生的话,从基类继承的成员都会私有,再拿基类指针指,首先会窄化,结果什么都访问不到。因此如果用基类指针指向私有、保护派生类对象,会直接在编译的时候报错
虚函数定义
在基类中被关键字virtua修饰,派生类中virtual可省略
这里的virtual和前文的虚继承一点关系都没有,同名纯属巧合
实现原理
一个类有虚函数,则会定义虚函数表,本类只有一个。本类对象中都有虚函数表指针。虚函数表是函数指针数组,指向每个虚函数。
派生类继承了虚函数,则也继承了虚函数表(复制了虚函数表)。如果重写虚函数,则修改虚表中函数指针,否则仍指向基类虚函数。
编译阶段创建对象及类的虚表。运行时用基类指针访问到派生类对象,找到其虚表指针,查表找到虚函数执行。所以编译时只绑定了指针(包括对象中的虚函数表指针、虚函数表中的函数指针),运行时根据指针才能绑定虚函数。 所以无论基类指针指向基类对象还是派生类对象,能做到不同对象对相同消息做出不同响应。 当基类指针指向派生类对象时,编译器以为是基类对象,但因为是虚函数,所以编译器建立虚函数表并在对象中存放虚函数指针,导致运行时调用重写的虚函数。
对于p->vfunc1()
,因为p是基类指针,则编译器已经将所指派生类对象隐式转为基类对象,所以无法判定调用哪个函数
注意事项
-
不能把静态成员函数声明为虚函数,因为静态成员函数不属于某个对象,而虚函数是通过对象指针或引用来调用的
-
构造函数不能是虚函数,因为执行构造函数时,对象还没有实例化。但析构函数可以是虚函数,且有时是必须的
针对第二点析构的,打个比方A *p = new B;
,new了一个派生类对象,但是用的基类指针,也就是说最后调用了基类的析构,会导致派生类中新定义的成员无法销毁。因此析构函数也必须重写。
每个类的析构函数负责销毁自己新定义的成员,派生类只需要销毁掉新定义的即可,至于继承来的成员,会调用基类的析构销毁。整个流程就是:基类指针调用析构(虚函数),派生类析构,由于继承关系,基类析构(这里和虚函数没关系,纯属是“继承”的特性)
析构的虚函数有其特殊性,比如在基类和派生类中函数名不同,但就运行时多态而言,与其他虚函数性质一样。
详细研究虚析构函数在虚函数表情况,参见:c++虚析构函数在虚函数表中吗?
纯虚函数和抽象类
纯虚函数是一个在基类中说明的虚函数,它在该基类中仅定义了函数首部,必须在派生类中重写
定义:virtual 返回类型 函数名(参数表)=0;
有纯虚函数的类称为抽象类,其无法被实例化,不能做函数参数、返回类型或转换类型,但抽象类指针、引用可以
5. 模板
分为函数模板和类模板,是实现代码重用机制的一种工具
5.1 函数模板与模板函数
使用函数模板时需要实例化,可以显式、隐式实例化
template <typename T>
void swap(T &a, T &b){...}
//隐式
int main(){
int x=1,y=2;
swap<int>(x,y);
//或swap(x,y);
....
}
//显式
template
void swap(int &a,int &b);
int main(){
int x=1,y=2;
swap(x,y);
....
}
函数模板中没有隐式的类型转换(形参到实参),但是重载后的模板函数(也就成了普通函数)是可以隐式转换的
template <class T>
T max(T x, T y) {
return (x > y) ? x : y;
}
void func(int i, char c) {
max(i, i); // 正确 调用max(int,int)
max(c, c); // 正确 调用max(char,char)
max(i, c); // 错误 类型不匹配
max(c, i); // 错误 类型不匹配
}
解决方法:
-
采用强制类型转换,如将上述
max(i,c);
改写为max(i,int(c));
-
用非模板函数去重载函数模板
char max(int x, char y) {
return (x > y) ? x : y;
}
-
这样就会调用这个普通的重载函数
模板函数、函数重载的匹配次序
优先级为:
-
参数完全匹配的(重载或实例化)函数
-
(隐式)实例化后能匹配的模板函数
-
类型转换后能匹配上的重载函数
例如
template <class T>
T myMax(T x, T y) { // 模板
// ...
}
int myMax(int x, int y) { // 重载1
// ...
}
char myMax(int x, char y) { // 重载2
// ...
}
int main() {
int i = 10;
char c = ‘a’;
float f = 43.74;
cout << myMax(i, i) << endl; // 重载1
cout << myMax(c, c) << endl; // 模板
cout << myMax(i, c) << endl; // 重载2
cout << myMax(c, i) << endl; // 重载2 (隐式转换)
cout << myMax(f, f) << endl; // 模板
cout << myMax(f, i) << endl; // 隐式转换是必须的,但是既可以转成重载1,又可以转成重载2
// 此时选择哪一个由编译器决定,不同编译器可能有不同选择
return 0;
}
6. 代码巩固
运算符重载
有一个String类,只有一个成员变量
class String {
char* array;
}
1)重载[]
这里为了理解面向对象的一些点,采用了很奇怪的写法,仅仅保证语法无误
关注点:返回值应该是引用
char& operator[](int i) {
if (i < 0 || i >= strlen(array)) {
cout << "Index out of range." << endl;
static char dummy = '\0';
return dummy;
}
return array[i];
}
2)重载+
如果要做String + String
的运算
这是一种返回临时对象的写法
String operator+(const String& s) { // 形参中的const和引用都可省略,语法上没问题
String temp(array);
temp.array = new char[strlen(array) + strlen(s.array) + 1];
strcpy(temp.array, array);
strcat(temp.array, s.array);
return temp;
}
如果要做String + char*
的运算
-
一种方法是重载
+
运算符,接收一个char*
类型的参数 -
一种方法是使用类型转换
比如把
char*
转为String
,用构造函数就可以实现,运算时编译器会自动隐式转换,从而转为String + String
。需要注意的是,这种方法会把
char*
转为一个临时对象String
,这个临时对象作为+
函数参数传入时,函数形参必须声明为const。也就是说,运算符重载函数接收一个临时对象时,必须是const。若把
String
转为char*
,则需要重载char*()
但是这两种方法不能同时使用,即不能同时有
char*
->String
和String
->char*
,否则会有二义性:既可以转为char* + char*
,又可以转为String + String
提供隐式类型转换
整个思路是:A重载了+
运算符,但是只能和A相加,因此这里给B提供了一个转化为A的类型转换重载,编译器在计算a+b
时,会自动把b隐式转换为a
class A {
int a;
public:
A() { a = 0; }
A(int i) { a = i; }
int operator+(const A& aa) { return a + aa.a; }
};
class B {
int b;
public:
B() { b = 0; }
operator A() { return A(b); }
};
int main() {
A a;
B b;
cout << a + b << endl;
return 0;
}
输出运算符重载
如正文所讲,<<
只能采用友元函数重载,并且返回值得是引用,第一个参数得是引用,第二个参数中如果要接收一个临时对象,必须用const修饰
friend ostream& operator<<(ostream& out, const String& s) {
out << s.array;
return out;
}
编译器的移动构造优化
class A {
int x;
public:
A(int i = 0) { // 构造
x = i;
cout << "construct";
}
A(const A& a) { // 拷贝构造
cout << "copy";
}
A operator+(const A& a) { // 重载+
cout << "add";
return A(x + a.x);
}
void operator=(const A& a) { // 重载=
cout << "equals";
}
};
int main() {
A a, b;
A c = a;
A d = a + b;
return 0;
}
这段代码最终输出为:con con copy add con
分析:
-
A a, b;
两次默认构造 -
A c = a;
标准的拷贝构造 -
A d = a + b;
显然先有一次+
重载,之后编译器会优化,效果等价于A d(a + b);
也就是一次普通构造
怎么区分 =
是拷贝构造还是赋值运算呢?只有在初始化对象的时候,才会使用拷贝构造,如果对象已经被创建了,之后的=
都是赋值
小综合
题目:
有四种几何图形:三角形、矩形、正方形和圆。求四种几何图形的面积之和。
定义一个包含两个虚函数的类
class Shape {
public:
virtual float Area(void) = 0; // 求面积
virtual void SetData(float, float = 0) = 0; // 设置几何形状参数
// 不同集合形状需要1个或2个参数,故采用默认参数值
};
公有派生各类,重写两个函数,这里只展示一个类,其余同理。
class Triangle : public Shape {
float W, H; // 三角形边长为W,高为H
public:
Triangle(float w = 0, float h = 0) {
W = w;
H = h;
}
float Area(void) { // 重写虚函数
return W * H / 2;
}
void Setdata(float w, float h = 0) { // 重写虚函数
W = w;
H = h;
}
};
这里使用了一个指针数组,来实现多态;如果采用对象数组,则无法实现多态
class Compute {
Shape** s; // 指向基类的指针数组
public:
Compute() { // 给几何图形设置参数
s = new Shape*[4];
s[0] = new Triangle(3, 4);
s[1] = new Rectangle(6, 8);
s[2] = new Square(6.5);
s[3] = new Circle(5.5);
}
float SumArea(void);
~Compute();
void Setdata(int n, float a, float b = 0) { s[n]->Setdata(a, b); }
};
float Compute::SumArea(void) {
float sum = 0;
for (int i = 0; i < 4; i++)
sum += s[i]->Area(); // 通过基类指针实现多态性
return sum;
}
Compute::~Compute() {
for (int i = 0; i < 4; i++)
delete s[i];
delete[] s;
}
文章转载自:laobei-uu