C++面向对象高级编程(九)Reference与重载operator new和operator delete

摘要: 技术在于交流、沟通,转载请注明出处并保持作品的完整性。


一 Reference

引用:之前提及过,他的主要作用就是取别名,与指针很相似,实现也是基于指针.

1.引用必须有初值,且不能引用nullptr

2.引用之后不能再引用别人

3.引用通常不用于声明变量,多用于参数类型,和返回值类型

见下面代码

int main(int argc, const char * argv[]) {

    int x=;

    //p is a pointer to x
int* p = &x; // r is a reference to x
int& r = x; //这个操作并不是r引用了别人而是 是r引用的x = 5
int x2 = ;
r = x2; // x = 5 cout << "x = "<< sizeof(x) << endl;
cout << "r = "<< sizeof(r) << endl;
cout << "r的地址 = "<< &r <<endl;
cout << "p的地址 = "<< p <<endl;
return ;
}

输出结果

C++面向对象高级编程(九)Reference与重载operator new和operator delete

你会发现 r的地址个p的地址是相同的,其实引用并没有实际的内存,为了实现引用的取别名的假象,编译器会这么做 sizeof(r) = sizeof(x)和 &x = &r

4.引用是指针,是一种漂亮的指针

void func2 (string* obj) { obj ->clear();} //pass by pointer
void func1 (string obj) { obj .clear();} //pass by value
void func3 (string& obj) { obj .clear();} //pass by reference

调用端

    string a;
//pass by pointer 接口不同
func2(&a); //pass by value 调用接口相同 效率低
func1(a); //pass by reference 调用接口相同
func3(a);

5.不能用引用区分函数签名

double imag(const double& im) {return im;};
double imag(const double im) {return im;};

调用的时候你会发现

C++面向对象高级编程(九)Reference与重载operator new和operator delete

错误提示是函数调用混淆,你会发现不能用引用区分函数签名(上面红色部分为函数签名)

const也算函数签名的一部分


二 多态

带vaiturl  内存上会多一个4字节的指针

继承是继承调用权 而不是继承内存大小

动态绑定的三个前提

1.必须通过指针调用

2.指针为向上的关系(保证安全)

3.调用的是虚函数

(*(p->vptr)[n])(p));

(*p->vptr[n])(p)


三 const

a.const object(data member不得改变)

b.non-const object(data member可以改变)

c.const member function(保证不改变data member)

d.non-const member functions(不保证 data member不变)

他们的组合关系

C++面向对象高级编程(九)Reference与重载operator new和operator delete

当成员函数的const 和non-const版本同时存在,const object 只会调用const 版本,non-const object 只会调用non-const

我们思考一下

const String str("Hello world");
str.print();

如果print()不加const[const object与non-const member function] 会报错

Copy On Write,带const 不用考虑 COW

class template std::basic_string<...>

//里面有两个member function 

charT operator[] (size_type pos) const {不考虑COW == Copy On Write};

reference operator[](size_type pos){必须考虑COW};

四 New 和 Delete

之前提过

new   = malloc() + ctor

delete = dtor + free()

new 和delete不可以重载 但是 operator new 和 operator delete可以重载

class Foo
{
public: Foo()
{
cout<< "Foo ("<< ++ctorNum << ")"<<endl;
}
~Foo()
{
cout<< "~Foo ("<< ++dtorNum << ")"<<endl;
}
//重载成员operatpr new
void* operator new(size_t size) noexcept
{
cout<< "Foo operator new" <<endl; return malloc(size);
}
//重载成员operatpr delete
void operator delete(void* ptr, size_t size)
{
cout<< "Foo operator delete" <<endl;
free(ptr);
}
}

调用端

int main()
{
Foo * p = new Foo;
delete p;
}

结果

C++面向对象高级编程(九)Reference与重载operator new和operator delete

发现我们接管了 operator new 和operator delete

class Foo
{
public: Foo()
{
cout<< "Foo ("<< ++ctorNum << ")"<<endl;
}
~Foo()
{
cout<< "~Foo ("<< ++dtorNum << ")"<<endl;
}
//重载成员operatpr new
void* operator new[](size_t size)
{
cout<< "Foo operator new" <<endl; return malloc(size);
} //重载成员operatpr delete[]
void operator delete[](void* ptr, size_t size)
{
cout<< "Foo operator delete[]"<<endl;
cout << size <<endl;
free(ptr);
} static int ctorNum;
static int dtorNum;
}; int Foo::ctorNum = ;
int Foo::dtorNum = ;

调用端

int main()
{
Foo* l = new Foo[];
delete[] l;
return ;
}

结果

C++面向对象高级编程(九)Reference与重载operator new和operator delete

我们可以重载多个版本的class menber operator new() 第一参数必须为 size_t

我们可以重载 class member operator delete() 可以重载过个版本 ,但是他们绝对不会被delete

调用重载的delete()只有当new所调用的ctor抛出 exception 才会调用这些重载版的operator delete() 它只可能这样被调用,主要用归还未能完全城建成功的object所占用的 内存

调用会一一对应 ,如果你的delete()与new() 没有一一对应编译器  也不会报错 表示放弃对异常做处理放弃

   class Bad{};//抛出异常用
class test
{
public:
test(){}
test(int i){/*故意抛出异常*/ throw Bad();}
~test(){}
//一般的operator new()
void* operator new(size_t size){cout<< "一般的operator new()" <<endl; return malloc(size);}
     //一般的operatpr delete
void operator delete(void* ptr, size_t size){cout<< "一般的operator delete()"<<endl; free(ptr);}
//标准库的operator new()
void* operator new(size_t size, void* start){cout<< "标准库的operator new()" <<endl; return start;}
//标准库的operator delete()
void operator delete(void*, void*){cout<< "标准库operator delete(void*, void*)" <<endl;}
//崭新的operator new()
void* operator new(size_t size, long extra){cout<< "崭新operator new()" <<endl; return malloc(size + extra);}
//崭新的operator new()
void operator delete(void*, long){cout<< "崭新operator delete(void*, long)" <<endl;}
//又一个operator new()
void* operator new(size_t size, long extra, char init){cout<< "又一个operator new()" <<endl; return malloc(size + extra);}
//又一个operator delete()
void operator delete(void* size, long extra, char init){cout<< "又一个operator delete()" <<endl;}
};

调用及输出

int main()
{
try{
test t;
test* p1 = new test;
test* p2 = new (&t) test;
test* p3 = new() test;
test* p4 = new(,'a') test;
test* p5 = new() test();
test* p6 = new(,'a') test();
test* p7 = new(&t) test();
}
catch(...){};
return ;
}

C++面向对象高级编程(九)Reference与重载operator new和operator delete

发现new和delete是一一对应,至于其他的为什么没有打印出来是由于,new不成功抛出异常导致

完!

参照<<侯捷 C++面向对象高级编程>>

上一篇:工控安全入门(二)—— S7comm协议


下一篇:自制C#版3DS文件的解析器并用SharpGL显示3DS模型