C++问题的补充

前言

关于对之前遗留的补充

malloc 和 new 的区别 const 和 引用 的深入 this指针 的深入

一    
    
    
 、C++中对象的创建

malloc和new创建对象

//定义一个Pointer类 class Pointer { public: int row; int col; Pointer() { row = 0; col = 0; } Pointer(int r, int c) { row = r; col = c; } ~Pointer() { cout << "Pointer" << endl; } };

malloc不能创建对象    
    
    
 ，需要配合定位new使用

//什么是 定位new 定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象    
    
    
 。 换句话说就是 


     


     


     ，现在空间已经有了

 




 




 




，不需要定位new像常规new一样去给申请 空间   

   

   

，只需要定位new在已有的空间上调用构造函数构造对象而已 


     


     


     。 简而言之  

     

     

     ，已存在空间


  




  




  



，再构造对象

 




 




 




。

malloc作用：

1 


     


     


     、堆区申请空间 2

 




 




 




、堆区无对象 //定位new  


  


  


，在已有(malloc申请的)空间上   
     
     
    ，构造对象 int main() { Pointer* s = (Pointer*)malloc(sizeof(Pointer)); new(s) Pointer(12, 23); s->~Pointer(); free(s); s = NULL; return 0; }

new创建对象的的过程：

1   

   

   

、调用malloc



   




   




   


，从堆区申请空间 2  

     

     

     、构建对象 



 



 



，调用构造函数 3


  




  




  



、对象地址空间返回给p //普通new                 ，先申请空间




    




    




    

，再创建对象 int main() { Pointer p1(100,200); Pointer p; p = new Pointer(10,20); delete p; return 0; }

二  


  


  


、new 和 malloc 的区别

区别 new malloc 属性 关键字 库函数 参数 无需指定内存块大小














，编译器实现 需要指定大小 返回类型 对象类型的指针 void * 重载 支持 不支持 内存 在free store上分配内存 在堆区空间分配内存 分配失败 bac_alloc异常 返回NULL 自定义类型 可以调用析构与构造 不可调用析构和构造 效率 高 低

三   
     
     
    、C与C++的一个重要区别

C语言：有空间一定能操作

C++： 有空间不一定有对象                 ，有对象一定要有空间

C

int main() { char str[10]; int* ip = (int*)str; *ip = 100; }

C++：有对象一定要有空间

//有对象一定有空间



     



     



     
，即使是空类 class Test { }; int main() { Test t; cout << sizeof(t) << endl; //空类大小为1 return 0; }

空类的大小：

声明类型时也需要占用一些空间

如果没有这个空间















，也就不知道该类型的存在   

   

   

。

空类具体占用的空间大小由编译器决定    
    
    
 ，vs2022中大小为1

编译器自动为其安插1个char  

     

     

     。 //有空间可能没对象 int main() { CGoods* p = (CGoods*)malloc(sizeof(CGoods)); cout << p->GetPrice() << endl; //结果：-4.31602e+08 }

四



   




   




   


、this指针

1. 什么是this指针

例子代码如下：

//一个商品类型 class CGoods { private: char Name[21]; int Amount; float Price; float Total_value; public: void RegisterGoods(const char[], int, float); //注册商品 void CountTotal(); //总共数量 void GetName(const char[]); //获得名字 int GetAmount(void); //读取商品 float GetPrice(void); //得到价格 float GetTotal_value(void); //总价 }; void CGoods::RegisterGoods(const char name[], int amount, float price) { strcpy_s(Name, 21, name); //strcpy_s(this->Name, 21, name); Amount = amount; //this->Amount = amount; Price = price; //this->Price = price; } void CGoods::GetName(const char name[]) { strcpy_s(Name, 21, name); } int CGoods::GetAmount(void) { return Amount; } float CGoods::GetPrice(void) { return (Price); } int main() { CGoods c1, c2, c3; c1.RegisterGoods("C++", 12, 98.99); c2.RegisterGoods("C++", 23, 15.9); c3.RegisterGoods("C++", 44, 54.3); return 0; }

这里并没有this的存在 


     


     


     ，那么this指针在哪呢?

首先来看一下C++模型对象的安排

方法一：各对象完全独立的安排内存

上图是系统为c1

 




 




 




，c2   

   

   

，c3对象分配了全套的内存  

     

     

     ，包括安放成员数据的数据区和安放成员函数的代码区


  




  




  



。但是区别同一个类所实例化的对象


  




  




  



，是由属性(数据成员)的值决定  


  


  


，不同对象的数据成员的内容是不一样的   
     
     
    ，而行为(操作)是用函数来描述的



   




   




   


，这些操作的代码对所有的对象都是一样的  


  


  


。

方法二：数据区私有 



 



 



，代码区公有

在C++中                 ，通过公共代码区节省了大量的空间   
     
     
    。

那么对象是如何区分哪个是自己的数据区呢？

this指针就是解决这个问题的



   




   




   


。

2. this指针的底层

首先明确几个概念：

this指针不属于对象的一部分




    




    




    

，不会影响sizeof(对象)的结果 



 



 



。 只有在类的非静态成员函数中才可以使用this指针














，其它任何函数都不可以                 。 this的作用域在类成员函数的内部






    




    




    

。

当在类的非静态成员函数中访问类的非静态成员的时候                 ，编译器会自动将对象本身的地址作为一个隐含参数传递给函数














。也就是说



     



     



     
，即使你没有写上this指针















，编译器在编译的时候也是加上this的    
    
    
 ，它作为非静态成员函数的隐含形参 


     


     


     ，对各成员的访问均通过this进行                 。

仍然是上一个例子：

//注释为本质 //成员方法的第一个参数添加一个对象类型的this指针



     



     



     
。 //成员方法中出现的所有成员属性由this指针指向















。 void CGoods::RegisterGoods(const char name[], int amount, float price) //void CGoods::RegisterGoods(CGoods *this,const, const char name[], int amount, float price) { strcpy_s(Name, 21, name); //strcpy_s(this->Name, 21, name); Amount = amount; //this->Amount = amount; Price = price; //this->Price = price; } int main() { c1.RegisterGoods("C++", 12, 98.99); //对象 + . 调用成员方法的本质 //逻辑上面向对象

 




 




 




，实际上是面向过程 //RegisterGoods(&c1, "C++", 12, 98.99); }

这样就不难理解   

   

   

，当通过 对象 + . 调用成员方法时  

     

     

     ，会将对象的地址作为第一个参数传递给成员方法


  




  




  



，这也是一个对象数据区的唯一标识    
    
    
 。得到该地址以后  


  


  


，调用成员函数中如果遇到成员属性   
     
     
    ，就给每个属性前面加上this 


     


     


     。

3.this指针 的类型

this指针的类型为 : 类型名 * const this



 




 




 




。

但是在VS2022中发现并没有这个const



   




   




   


，不知道是什么情况

4. C++类成员函数默认调用方式 与 c语言调用方式的区别

C++默认调用(C++成员函数的this指针)

void CGoods::RegisterGoods(const char name[], int amount, float price) { strcpy_s(Name, 21, name); //strcpy_s(this->Name, 21, name); Amount = amount; //this->Amount = amount; Price = price; //this->Price = price; } void CGoods::GetName(const char name[]) { strcpy_s(Name, 21, name); } int CGoods::GetAmount(void) { return Amount; } float CGoods::GetPrice(void) { return (Price); } int main() { CGoods c1, c2, c3; c1.RegisterGoods("C++", 12, 98.99); //C++的调用约定 lea ecx , [c1] c1.CountTotal(); return 0; }

对象 . 调用成员方法 



 



 



，逻辑上是面向对象                 ，物理上还是面向过程




    




    




    

，会将对象地址传递给成员函数的this指针   

   

   

。对象的地址传递时候














，直接进行 lea ecx, [c1]  

     

     

     。到达成员函数内部时                 ，使用mov指令



     



     



     
，将ecx的值传递给this指针


  




  




  



。

c语言调用方式（thiscall调用）

在成员函数前面加上__cdecl















，说明是C的调用约定    
    
    
 ，我们可以将c1的地址传递给eax 


     


     


     ，通过push指令入栈eax

 




 




 




，直接传递给形参  


  


  


。

//通过使用__cdecl改写 thiscall //void __cdecl CGoods::RegisterGoods(const char name[], int amount, float price)；

5 



 



 



、this 与 常对象

常对象只能调用常方法   

   

   

，普通对象能调用普通方法和常方法   
     
     
    。

例子：

//main函数中  

     

     

     ，哪些语句能编译通过 class CGoods //设计类型


  




  




  



，不是定义类型 { private: char Name[21]; int Amount; float Price; float Total_value; public: CGoods(char name[], int amount, float price, float total_value) { strcpy_s(Name, name); Amount = amount; Price = price; Total_value = total_value; } void RegisterGoods(const char[], int, float); float GetPrice(void) { return Price; } float GetTotal_value(void) const { return Total_value; } }; int main() { CGoods c1 = { "C++",12,23.0,23.0 }; const CGoods c2 = { "java",12,23 }; c1.GetPrice(); //right：普通对象调用普通方法可以通过this指针修改成员函数的值 c2.GetPrice(); //error：常对象不能调用普通方法



   




   




   


。常对象调用普通方法时  


  


  


，成员属性有修改的风险   
     
     
    ，所以报错 



 



 



。 c1.GetTotal_value(); //right：普通对象既可以调用普通方法又可以调用常方法 c2.GetTotal_value(); //right：常对象只能调用常方法 }

我们知道了this指针的类型是 对象名 *const this                 。那么对象加 const 也就是const 对象名 *const this类型



   




   




   


，为了给this指针所指向的对象限定 



 



 



，也就是不允许修改对象中的成员属性                 ，那么任何对成员属性进行修改的行为都是错误的




    




    




    

。

四                 、const 回顾

int main() { const int a = 10; int b = 20; int* p1 = &a; //error:可以通过p1改变a const int* p2 = &a; //right:p2所指向的值不能修改 int* const p3 = &a; //error：可以通过p3改变a




    




    




    

，但不能改变p3的指向 const int* const p4 = &a; //right：能力收缩 return 0; }

五




    




    




    

、构造函数和析构函数

1.构造函数和析构函数的用法

class Pointer { public: int row; int col; //构造函数： //1














、函数名与类名相同 //2                 、无返回值 //3



     



     



     
、对象实例化时














，编译器自动调用 //4















、可以重载 Pointer() //无参构造函数                 ，缺省构造 { row = 0; col = 0; } Pointer(int r, int c) //构造函数重载 { row = r; col = c; } ~Pointer() //析构函数 { cout << "Pointer" << endl; } //析构函数： //1    
    
    
 、~ + 类名 //2 


     


     


     、析构函数无函数返回值类型 //3

 




 




 




、一个类只能一个也只能有一个析构函数 //4   

   

   

、对象注销时



     



     



     
，系统会自动调用 //5  

     

     

     、如果没有给出析构函数















，系统会给出默认析构函数 }; int main() { Pointer c1 = { 12,23 }; Pointer c2; //right：调用缺省构造函数 //Pointer c2(); //error：没有参数不需要带括号 Pointer c3(10, 20); //right：调用带参数构造函数 //不能通过对象手动调用构造函数 //c2.Pointer(10,20); //error //有空间不一定有对象    
    
    
 ，得要对象调用构造函数来构建对象 


     


     


     ，才有空间 //有对象一定有空间 return 0; }

2.构造函数和构造函数的执行顺序

留给后面

class Object { private: int val; public: Object(int x) { val = x; cout << "create :" << val << endl; } }; Object o1(1); int main() { Object o2(2); } Object o3(3);

已解决：程序执行顺序

总结

待解决的问题：

const 和 引用 的深入 [程序执行顺序] 类中的默认成员方法