inline修饰函数,是给编译器的一个建议,到底是否为inline由编译器来决定,inline修饰的函数在使用时是做简单的替换,这样就避免了一些函数栈空间的使用,从能提升效率。从另一种角度看,是替代宏的一种方法。
构造函数为成员变量赋值,可以在初始列表赋值,也可以在函数体中赋值。但是,较为大气的写法是在初始列表中做,这样会大气!一些!懂不懂什么是大气?
在编译器中,对于重名的函数,也就是重载的函数,做编译的时候,对给同名的函数加上不同的后缀,比如说,两个real函数,一个有参数,一个无参数,那么编译结果可能是:real@Complex@@XFNGHW,real@Complex@@XFGHERF
const函数表示函数不会改变成员变量内容,不改变成员变量的函数一定要加。如果声明一个const的类对象,表明这个类对象里面的值不能修改,但是类成员函数没有声明成cosnt,这样就会报错。
COW:copy on write,写时复制,在写的时候才进行复制,没写的时候,共享同一个字符串
charT
operator[] (size_type pos) const {
//不必考虑写时复制的问题,效率高,string[1]
}
reference
operator[] (size_type pos){
//要考虑写时复制的问题,string[1] = 't'
}
当成员函数的const版本和non-const版本同时存在的时候,const 对象只能调用const版本,non-const对象只能调用non-const版本
尽量不要值传递,建议使用引用传递。引用传递底部是一个指针,一个指针四个字节,很快,啊,啪的一下,所以,传引用就相当于传指针。如果不希望函数修改引用的值,可以加const加以限制。函数返回值也尽量使用引用。
引用传参,传递者无需知道接收者以什么引用形式接收。
一个类想要拿到另一个类的私有成员变量,那么就需要在另一个类中把这个类声明为友元。但是同一个类之间的不同实例能够取到彼此之间的私有成员变量,因为,相同class的各个对象互为友元。
拷贝赋值要检测是不是自我赋值,如果没有这个操作,可能会发生错误:因为拷贝赋值需要先进行delete操作,如果是自我赋值,那么delete掉本体,那么指向这个内存的另一个指针也会找不到相应的值,从而报错。
C++内存模型分成五个部分:堆、栈、全局/静态存储区(C语言还分.bss段和.data段)、常量区、代码区
new的内部步骤:1.分配内存 2.转化类型 3.构造函数
delete步骤:1.析构函数 2.释放内存
字节对齐可以通过#pragma pack(4)
进行设置,32位默认4字节对齐。
array new要搭配array delete,否则会造成内存泄露,为什么?对于没有指针的类,就算array new不搭配array delete也是不会发生内存泄露的。按照侯捷老师讲的内存模型,申请一个空间,带一个上下cookie,这个cookie中会存放当前内存块的大小,delete时是会完全释放掉这一个内存块的。但是对于有指针的类来说,申请一个该类型的数组,申请的空间中存放的是元素的指针,就算有上下cookie,delete能释放掉指针所占的空间,但是不能释放掉指针指向的内存空间。所以,使用array delete也就是delete[],就是为了告诉编译器,我们需要多次调用当前类的析构函数,去释放指针指向的内存。
将一个类型转化为另一个类型,比如说将分数转化为double,那么需要在分数类中重载double操作类型:
class Fraction{
public:
operator double() const{
return (double) (m_numerator/m_denominator);
}
private:
int m_numerator;
int m_denominator;
}
下面这个类的构造函数就是non-explicit的
class Fraction{
public:
Fraction(int num, int den=1)
:m_numerator(num), m_denominator(den){}
Fraction operator + (const Fraction& F){
return Fraction(...);
}
private:
int m_numerator;
int m_denominator;
}
当这么使用的时候:
Fraction a = f + 4;
4就会调用构造函数来将4转化为一个Fraction类
如果在这个构造函数前加上关键词 explicit,就代表明确的构造函数,不会将该构造函数用于类型转化
比如说shared_ptr重载了运算符*和->
迭代器也可以看作是一种智能指针
重载()
个数上的偏特化,范围上的偏特化(比如说从类型T到指针类型U,范围缩小了)。
只有在模板的尖括号中,class和typename共通,没有区别
还可以有成员模板。
template<typename T,
template <typename T>
class Container>
上面这个就是模板模板参数,模板中还有模板,模板中模板使用前一层的模板的class当作参数。
针对这个问题,可以引入一个using语法:
template<typename T>
using Lst = list<T, allocator<T>>;
XCls<string, Lst> obj;
必须是模板!最先定义的入口函数,必须有两个参数,一个是firstArg,一个是args…
第二种操作会作用到原来的元素上。
for(auto elem : vec){
...
}
for(auto& elem : vec){
elem *= 3;
...
}
引用必须要有初值
引用的实现是用指针,但是它不能再改变指向,引用代表的东西是多大,这个引用就是多大(这个是编译器做出来的假象)
引用的地址和他所代表的变量的地址、值完全相同
引用是一种漂亮的指针
引用通常不用于声明变量,而用于参数类型和返回类型的描述
void func1(cls* pobj) {pobj->xxx;}
void func2(cls pobj) {pobj.xxx;}
void func3(cls& pobj) {pobj.xxx;}
...
Cls obj;
func1(&obj);
func2(obj);
func3(obj);
可以看到,使用引用传递,行为和传值相同。
同名函数,传值和传引用是同一个函数,而不是重载,如果同时存在,就会存在二义性
组合:has-a
继承:is-a
委托:有一个另一个类的指针,composition by reference
继承关系下的构造和析构
构造,由内而外,先构造父类,后构造自己
析构,由外而内,先析构自己,够析构父类
继承+复合关系下的构造和析构
构造,先调用父类的构造,然后调用复合的构造,最后调用自己的构造
析构,先调用自己的析构,然后调用复合的析构,最后调用父类的析构
一个类占的内存大小包括:成员变量,父类的成员变量,如果有虚函数则由一根,一根,一根虚函数表指针
虚函数只要在子类里面被重写,子类的虚函数表就会把重写的函数的指针改变指向,和父类的指针不指向同一个地址
通过指针,指针向上转型,调用的是虚函数,满足这三个条件,就会是动态绑定
继承了一个有虚函数表的类,那么也会有自己独立的虚函数表,如果没有重写,那么这个独立的虚函数表指向的函数地址不变,但是如果重写了,就会将对应的函数地址指针指向改变,就相当于有一个自己的实现,这才能完成多态。A *p = new B()
,这么一句,B有自己的虚函数表,A类型的指针指向了B类的地址,使用A调用虚函数的时候,其实是调用B类的虚函数表中的函数,所以叫之为动态绑定,但是使用A调用非虚函数的话,还是使用的是A自己里面的非虚函数,本质上来说,指针p还是A类型的,而且A类型里面的非虚函数没有经过动态编译。
通过对象调用,不会动态绑定,只有通过指针调用才会动态绑定。
通过一个对象调用一个函数,那个对象的地址就是this指针,所有的成员函数都有一个隐藏的this指针,就像python中的self一样,该函数中的类成员变量,类成员函数都是通过this指针来进行调用的。