深度探索C++模型----除第七章笔记

【A_Star三维路径规划】基于matlab A_Star算法结合B样条平滑三维地形路径规划(含雷达威胁)【含Matlab源码 3527期】 A_Star算法结合B样条平滑三维地形路径规划(含雷达威胁) 完整代码,包运行;可提供运行操作视频!适合小白! 阅读详情


第三章:Data语意学


3.1 Data Member的绑定
主要讲Alignment,之前做笔试题遇到过挺多的,大概就是不满计算机一个字节的会加入padding填充满这一个字节。
3.2 Data Member的布局
3.3 Data Member的存取
静态数据&非静态数据
Point3d origin;
origin.x=0.0;//x的存取成本分x是否为静态数据以及Point3d是否是独立的class。

重点:

Point3d origin,*pt=&origin;
origin.x=0.0;
pt->x=0.0;

问:这两种取法有什么重大差异。
.和->的问题,一个是针对对象,一个是针对指针。 
比如你有这个结构体:

struct xx
{
int a;
int b;
}yy, *kk;
yy.a=3, yy.b=5;
kk=new xx;
kk->a=4, kk->b=6;

class A
{
public :
    int a;
}
A ma;
A *p=&ma;

那么指针p应使用->来访问成员a,比如p->a,而ma应使用.来访问,比如ma.a区别就在这里,凡是指针就使用->,对象就使用.运算符。

只有当Point3d是一个derived class,而在其继承结构中有一个virtual base class,并且存取的member是一个从该virtual base class继承而来的member时就会有重大的差异。因为我们无法在编译时期知道这个member的真正的offset的位置,因此这个存取操作需要被延迟到执行期,经由一个额外的间接导引才能够解决。但如果使用引用就不会有这个问题,由于其类型无疑是Point3d类型,即使它继承自virtual base class,members的offset位置在编译时期也就固定了。一个积极进取的编译器甚至可以静态的经由origin就解决掉对x的存取。

非静态数据会以明喻的或者暗喻的方式去调用。
明喻(explicit)
暗喻(implicit)也就是使用隐含的this指针。
对nonstatic data member进行存取操作编译器需要把class object的起始地址加上data member的偏移量。对于data member来说:

//下面两种形式等价
&origin._y
&origin+(&Point3d::_y-1);//这个-1是对于data member来说的。

编译器会对data member的offset值进行加一使得编译器去区分"一个指向data member的指针,用以指出class的第一个member"和"一个指向data member的指针,没有指出任何member"的情况。相当于只要指出了member就需要-1还原。

3.4 继承与Data Member
a.单一继承而且没有virtual function时
这样做是没有virtual的成本的,也就是跟普通C结构没两样,没有额外的成本。
inline定义的函数会被放入符号表中,在使用时像宏一样展开进行替换,效率很高,并且会有参数检查,在类中定义还可以保护类的保护成员和私有成员。缺点在于代码过大过繁会造成很大开销。
b.加上多态,也就是引入了virtual function
c.多重继承
d.虚拟继承

3.5 对象成员的效率
实际上具体继承(非virtual继承)并不会增加空间或者存取时间上的额外负担,但是虚拟继承的间接性压抑了"把所有运算都移往缓存器执行"的优化能力,即使通过类对象访问编译器也会像对待指针一样,效率令人担心,一般来说virtual base class最有效地运用形式就是一个抽象的virtual base class,没有任何的data member。
虚函数到底有多慢:https://blog.youkuaiyun.com/hengyunabc/article/details/7461919
调用虚函数其实相当于多了3条汇编指令:根据指针或引用取虚表,取虚表的函数地址,对函数进行call调用。
call指令主要会影响CPU的流水线。
在获得引用和指针前无法进行内联优化。

3.6 指向Data Member的指针
&Point3d::z将得到z坐标在class object中的偏移量(offset)

上文提到过的-1操作是为了区分:
float Point3d::*p1=0;//Point3d::*的意思是:"指向Point3d data member"的指针类型。
float Point3d::*p2=&Point3d::x;
每次存取Point::x,也就是pB.*bx会被转化为&pB->__vbcPoint+(bx-1),而不是转化为最直接的&pB+(bx-1),因此会降低"把所有处理都搬移到缓存器中执行"的优化能力。

Base2* pb1 = new Derived;  // 调整指针指向base2 clss子对象
Base2* pb2 = pb1->clone(); // pb1被调整至Derived对象的地址,产生新的对象,再次调整对象指针指向base2基类子对象,赋值给pb2。

Derived* pDerived = new Derived;
Base2* pBase2 = pDerived; // Base2为Derived的第二个基类
pBase2 != pDerived;    // 两者不等,进行了this指针转换
class Point3d
{
public:
virtual ~Point3d();
protected:
static Point3d origin;
float x, y, z;
};

&Point3d::z;//返回的是float Point3d::*
&origin.z;//返回的是float*
//问:这两个之间的差异是什么?
//第一个会得到其在类中的offset,第二个会得到member在内存中的真正地址,因为它是绑定于真正classobject身上的data member地址。

 

第四章:Function语意学

name managling//重载时候的名字改编
extern "C"//实现C与C++混合编程

4.1 Member的各种调用方式
a.Nonstatic Member Function
C++设计的准则之一是nonstatic member function至少必须和nonmember function有相同的效率。也就是说在要有一样的访问速度。

float magnitude3d(const Point *_this){...}
float Point3d::magnitude3d() const{...}

实际上对于member function会被内化为nonmember的形式。

步骤一:给类成员函数添加一个this指针
Point3d Point3d::magnitude(Point3d *const this)
Point3d Point3d::magnitude(const Point3d *const this)
步骤二:对数据成员的调用改为this,如x改为this->x
步骤三:将成员函数名称进行mangling处理,使它在程序中成为独一无二的语汇

extern magnitude__7Point3dFv(
    register Point3d *const this);

此时函数转化操作已完成,而为每一个调用操作也都必须转化:

obj.magnitude();转为magnitude__7Point3dFv(&obj);
ptr->magnitude();转为magnitude__7Point3dFv(ptr);

关于named return value的介绍:
https://www.cnblogs.com/zzj3/articles/3728902.html
https://blog.youkuaiyun.com/luofengmacheng/article/details/21072255
https://www.cnblogs.com/autosar/archive/2011/10/09/2204181.html
NRV操作主要就是在返回一个对象时直接用返回值去取代函数内部的局部对象,此时函数只产生一个对象。而普通的编译器会在返回一个对象时会再创建一个临时对象用于获取返回值,因此函数会产生两个对象。

CTest(const CTest& rcTest)//所谓的拷贝构造函数
{  
    cout << "CTest(CTest)" << this << endl;  
} 
void bar(X& __result)  
{  
    // 调用__result的默认构造函数  
    __result.X::X();    
    // 处理__result  
    return;  
}
// 函数实现  
void bar(X& __result)   // 加上一个额外参数  
{  
    // 预留x1的内存空间  
    X x1;    
    // 编译器产生的默认构造函数的调用,  
    x1.X::X();    
    // 处理 x1..    
    // 编译器产生的拷贝操作  
    __result.X::X(x1);    
    return;  
}
// 函数调用  
X x2;                   // 这里只是预留内存,并未调用初始化函数  
bar(x2); 

NRV这里涉及了一个拷贝构造函数的问题,默认的拷贝构造函数是浅拷贝,也是位拷贝,没有进行过内存的开辟而是直接给变量添加了一个引用,如果原始变量被删除就会产生一个野指针。位拷贝的效率也不见得高效,因此自定义拷贝构造函数很重要,举两个例子。

class A
{
public:   
    A()   
    {       
        data = new char;        
        cout << data << endl;        
        cout << "默认构造函数" << endl;  
    }
    
    A(const A& a)//深拷贝  
    {       
        data = new char;       
        memcpy(data, a.data, sizeof(a.data));    
    }
 
    //浅拷贝
    /*A(const A& a)   
    {        
        data=a.data;
    }*/   
    ~A()    
    {       
        cout << "析构函数" << endl;        
        delete data;        
        cout << data << endl;        
        data = NULL;  
    }
private: 
    char* data;
};

class CA
{
 public:
  CA(int b,char* cstr)
  {
   a=b;
   str=new char[b];
   strcpy(str,cstr);
  }
  CA(const CA& C)
  {
   a=C.a;
   str=new char[a]; //深拷贝
   if(str!=0)
    strcpy(str,C.str);
  }
  void Show()
  {
   cout<<str<<endl;
  }
  ~CA()
  {
   delete str;
  }
 private:
  int a;
  char *str;
};

调用方式:
    A a;
    A b(a);//A b=a;

b.Virtual Member Function

virtual Point3d::normalize();
ptr->normalize()=>(*ptr->vptr[1])(ptr);//第二个ptr表示this指针
obj.normalize()=>(*obj.vptr[1])(&obj)=>normalize__7Point3dFv(&obj)

c.Static Member Function

((Point3d*)0)->object_count();


4.2 Virtual Member Function
什么是RTTI:其存储着类运行的相关信息,比如类的名字,以及类的基类。可以在运行时识别对象的信息。C++里面只记录类的名字和类的继承关系链,是的编译成二进制的代码中对象可以知道自己的名字,以及在继承链中的位置。

const type_info& typeinfo = typeid(pbase);
cout << typeinfo.name()<<endl;//输出pbase的类型class Base*
if(NULL != dynamic_cast<Derive*>(pbase))
{
    cout<<"type: Derive"<<endl;//type:Derive
}
else if(NULL != dynamic_cast<Derive2*>(pbase))
{
        cout<<"type: Derive2"<<endl;//type:Derive2
}
else
{
    //ASSERT(0);
}

C++中有4中强制类型转换符:dynamic_cast、const_cast、static_cast、reinterpret_cast。
其中dynamic_cast与运行时类型转换密切相关。该转换符用于将一个指向派生类的基类指针或引用转换为派生类的指针或引用,也就是dynamic_cast只能作用于含有虚函数的类。
B *pb; D *pd, md; pb=&md; pd=dynamic<D*>(pb);//含有虚指针的基类B和从基类B派生出的派生类D。
比如派生类D中含有特有的成员函数g(),这时可以这样来访问该成员dynamic_cast<D*>(pb)->g();但这个转换并不总是成功的。
dynamic_cast转换操作符在执行类型转换时首先将检查能否成功转换,如果能成功转换则转换之,如果转换失败,如果是指针则返回一个0值。因此pd=dynamic_cast<D*>(pb); if(pd){…}else{…},或者这样测试if(dynamic_cast<D*>(pb)){…}else{…}。

已知dynamic_cast依赖于RTTI,那么是如何绑定的?
原来虚表上面的地址是指向一个结构 Derive::`RTTI Complete Object Locator , 这个结构指向该类的名字,和其对象继承链。

实现一个代码用来从RTTI中读取类的名字:
https://www.cnblogs.com/zhyg6516/archive/2011/03/07/1971898.html


4.3 函数的效能
编译器将视为不变的表达式提到循环之外,因此只计算一次。因此inline函数不仅可以节省一般函数调用带来
的额外负担也提供程序优化的额外机会。


4.4 指向Member Functions的指针
获取地址:https://blog.youkuaiyun.com/microsues/article/details/6452249

Derived d;
cout<<"&d="<<&d<<endl;
int *vptr1=(int*)*((int*)&d+0);//vptr1为virtual table[0]的地址
int *pf1=(int*)*((int*)*((int*)&d+0)+0);//pf1为virtual table[0]里的第一个虚拟函数
Derived::~Derived的地址

int sz=sizeof(Base1)/4;
int *vptr2=(int*)*((int*)&d+sz);//vptr2为virtual table[1]的地址
cout<<"vptr2="<<vptr2<<endl;
pf1=(int*)*((int*)*((int*)&d+sz)+0);//pf1为virtual table[1]里的第一个虚函数
cout<<"&vptr2[0]="<<&vptr2[0]<<endl;//这里是virtual table[1][0]的地址
cout<<"pf1="<<pf1<<endl;//这里是virtual table[1][0]里存储的地址,也就是真正函数的地址

一个问题:开C语言深度剖析那本书的时候再细讲:

#include<iostream>
using namespace std;
int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int *ptr1 = (int*)(&a+1);
    int *ptr2 = (int*)((int)a + 1);
    printf("%x,%x", ptr1[-1], *ptr2);//ptr1[-1]值为5,ptr2会根据大小端来辨别。&a是一整个数组,而a也能代表一个数组但只存有a[0]一个。
    system("pause");
}


4.5 Inline Functions
由于调用函数的开销比求解等价表达式要慢得多,在大多数机器上调用函数需要在调用前先保存寄存器,并在返回时恢复,复制实参,程序还必须转向一个新位置执行。内联展开也就是省去了写成函数的开销。如下代码:

inline int max(int a, int b)
{
    return a > b ? a : b;
}
//会被内联展开为:cout<<max(a, b)<<endl;

inline函数不能包含循环、switch、if语句。
在一个c文件中定义的inline不能在其他c文件中使用,最好将inline函数定义在一个**-inl.h头文件中。
不要过度的使用inline。

 

第五章:构造、解构、拷贝 语意学

什么是POD:
1.所有的标量类型(基本类型和指针类型)、POD结构类型、POD联合类型、以及这几种类型的数组、const/volatile修饰的版本都是POD类型。
2.不能有用户自定义的构造函数、析构函数、拷贝构造函数。
POD的本质是与c兼容的数据类型。也就是不受虚函数、C++特性等的影响,可以在转化成二进制时不发生变化。

Point *heap=new Point会转换为对new运算符的调用:
Point *heap=__new(sizeof(Point));

delete heap会被转化为__delete(heap);

构造函数入栈,析构函数出栈
并且构造是从基类开始的,每一个继承的类都是从基类构造函数一层层构造上去的。

拷贝构造函数

Point::Point(Point &p)
{
    X=p.x;
    Y=p.y;
    cout<<"这里是拷贝构造函数"<<endl;
}

拷贝构造函数使用的三个地方:
a.用类的一个对象去初始化该类的另一个对象

Point A(1,2);
Point B(A);

b.函数的形参为类的对象

void fun1(Point p)
{
    cout<<p.GetX()<<endl;
}
Point A(1,2);
fun1(A);

c.函数的返回值是类的对象

Point fun2()
{
    Point A(1,2);
    return A;
}

拷贝赋值函数

class Foo
{ 
public: 
    Foo& operator=(const Foo&);//返回自引用,拷贝新内容。都是同类型引用。
}

重载是在一个类中有两个及以上的方法,要求方法名相同但参数却不相同。
动态重载与静态重载
动态重载是指继承多态,静态就是单纯的代码函数重载

int Max (int,int);//返回两个整数的最大值;
int Max (const vector <int> &);//返回vector容器中的最大值;
int Max (const matrix &);//返回matrix引用的最大值;
int Add  (int a,int b);
float Add(int a,float b);
float Add(float a,int b);
float Add(float a,float b);

 

第六章 执行期语意学

全局对象:class object会在编译时期放置在data segment并且内容为0,但constructor一直到程序及或是才会实施。cfront的实现策略是munch策略,会产生__sti()和__std()函数,以及一组运行时库,一个_main()函数,一个_exit()函数。
局部静态对象:
const Matrix & identity(){
    static Matrix mat_identity;//mat_identity的constructor和destructor必须只能执行一次,就算函数被调用很多次,会有一个临时变量的导入来判断constructor是否已经被调用过。
    return mat_identity;
}
对象数组:

#include<iostream>
using namespace std;
class CSample{
public:
    CSample(){  //构造函数 1
        cout<<"Constructor 1 Called"<<endl;
    }
    CSample(int n){  //构造函数 2
        cout<<"Constructor 2 Called"<<endl;
    }
}
int main(){
    CSample arrayl[2];
    cout<<"stepl"<<endl;
    CSample array2[2] = {4, 5};
    cout<<"step2"<<endl;
    CSample array3[2] = {3};
    cout<<"step3"<<endl;
    CSample* array4 = new CSample[2];
    delete [] array4;
    return 0;
}

输出结果:
Constructor 1 Called
Constructor 1 Called
stepl
Constructor 2 Called
Constructor 2 Called
step2
Constructor 2 Called
Constructor 1 Called
step3
Constructor 1 Called
Constructor 1 Called

 

class CTest{
public:
    CTest(int n){ }  //构造函数(1)
    CTest(int n, int m){ }  //构造函数(2)
    CTest(){ }  //构造函数(3)
};
int main(){
    //三个元素分别用构造函数(1)、(2)、(3) 初始化
    CTest arrayl [3] = { 1, CTest (1, 2) };
    //三个元素分别用构造函数(2)、(2)、(1)初始化
    CTest array2[3] = { CTest(2,3), CTest (1,2), 1};
    //两个元素指向的对象分别用构造函数(1)、(2)初始化
    CTest* pArray[3] = { new CTest(4) , new CTest(1,2) };
    return 0;
}


只要对象里声明了构造函数&析构函数,对象数组里的每个元素都需要进行构造&析构操作。
对象的new和delete

Point3d *origin=new Point3d;
//被转化为:
Point3d *origin;
if(origin=__new(sizeof(Point3d)))
    Point3d::Point3d(origin);

delete originl;
//被转化为
if(orgin!=0)
{
    Point3d::~Point3d(origin);
    __delete(orgin);
}


针对数组的new的情况:
如果class中定义有一个default constructor,某些版本的vec_new()就会被调用配置并构造class objects组成的数组。

Point3d *p_array=new Point3d[10];//通常会被编译为Point3d *p_array;
p_array=vec_new(0,sizeof(Point3d),10,&Point3d::Point3d,&Point3d::~Point3d);

 

【数据集】1970-2023年全球温室气体排放 GHG 数据集 EDGAR 1970-2023年全球温室气体排放 GHG 数据集 EDGAR 阅读详情

相关推荐

DSP28335与Vofa+上位机通信实战:SCIb配置避坑指南(附完整代码)

本文提供DSP28335与Vofa+上位机通信的实战指南,重点解析SCIb模块配置的常见问题与解决方案。针对研旭开发板的硬件连接、波特率精确计算、FIFO高效使用以及FireWater协议封装进行了详细说明,并附有完整代码,帮助开发者快速实现实时数据可视化与波形分析,提升调试效率。

weixin_29172963的博客 152

深度探索c++对象模型第五章笔记上

构造、解构、拷贝语意学(Semantics of Constuction,Destruction,and Copy) 假设有以下的代码: class Abstract_base { public: virtual ~Abstract_base()=0;//pure virtual function virtual void interface() const=0; virtual const...

Capr1corn的博客 336

信息抽取实战:三元组抽取(限定领域 vs 开放领域)(附代码)

信息抽取实战:三元组抽取 目录信息抽取实战:三元组抽取一、限定领域的三元组抽取比赛介绍数据分析序列标注模型关系分类模型三元组提取总结开放领域的三元组抽取标注平台文本分类新数据进行三元组抽取总结参考文献 一、限定领域的三元组抽取   本项目将会介绍在2019语言与智能技术竞赛的三元组抽取比赛方面的一次尝试。由于该比赛早已结束,当时也没有参加这个比赛,因此没有测评成绩,我们也只能拿到训练集和验证集。但是,这并不耽误我们在这方面做实验。 比赛介绍   该比赛的网址为:http://lic2019.ccf.org.

南有芙蕖 2万+

函数模板-C++平时作业

这周的C++作业是有关函数模板的编程题。先在网上找了一圈,虽然题目相似,但是老师明显动了手脚,稍微改难了一点,不过还是换汤不换药,所以我决定给这周的作业也发布一下。首先先讲一下,之前学过的函数重载,可以看出重载函数可以对于不同的类型的数据完成相似的操作,函数的名字相同,参数类型不同,却可以完成相同的功能。这大大提高了便程序编写的效率,使用函数模板就是为了达到这一目的,程序员只需对函数模板编写一次,...

m0_46218075的博客 1482

麒麟OS恢复出厂设置原理与实操:非重装的系统状态回滚

Linux操作系统中的‘恢复出厂设置’并非简单重装或镜像还原,而是一种基于状态快照、包管理与配置模板的可控回滚机制。其核心原理依赖LVM快照技术、RPM包签名验证和预置配置模板,兼顾系统稳定性与用户数据安全。该方案在政务、教育等国产化场景中具有显著技术价值——不格式化硬盘、不丢失/home文档、不重配驱动与授权,大幅降低运维复杂度。典型应用场景包括系统卡顿修复、软件冲突清理、桌面环境异常恢复等。本文深入解析银河麒麟V10的kylin-restore-cli工具链与麒麟管家集成逻辑,聚焦‘恢复出厂设置’这一高

weixin_30879169的博客 778

MicroLogix1400编程(使用RSLogix 500 + RSLinx Classic Lite)

MicroLogix1400编程

noscallion的博客 1万+

Data语意学

1. Data Member的布局   Nonstatic data members在class object的排列顺序将和被声明的顺序一样,任何中间介入的static data member都不会被放进对象布局之中。static data member存放在程序的data segment中,和个别的class objects无关。 2. Data Member的存取   i. 对于

kevin_liu11的专栏 329

程序化广告行业(2/89):从程序化广告深挖数据处理技巧

大家好!我一直希望能和大家在技术学习的道路上携手共进,这也是我写这一系列博客的初衷。上次我们一起学习了Python基础的数据处理知识,这次咱们借助一本程序化广告手册,深入挖掘数据处理的更多技巧。这本手册涵盖了程序化广告从概念到技术实现的诸多方面,而其中处处都涉及到数据处理,相信会给我们带来不少收获

yyy173611的博客 4572

深度探索c++对象模型之三 --- Data语意学

深度探索c++对象模型之三 — Data语意学

Aaron的专栏 971

Unity类银河恶魔城学习记录1-10 PlayerWallJump源代码 P37

Alex教程每一P的教程原代码加上我自己的理解初步理解写的注释,可供学习Alex教程的人参考

Homura_的博客 1381

【MeshLib & VTK】MeshLib PK VTK

本文分享三维几何处理库MeshLib,并将其与VTK进行对比,希望对各位小伙伴有所帮助!

qq_40041064的博客 1080

《深度探索c++对象模型》笔记

《深度探索c++对象模型》第一章笔记:《深度探索c++对象模型》第一章笔记_StudyWinter的博客-优快云博客《深度探索c++对象模型》第二章笔记:《深度探索c++对象模型》第二章笔记_StudyWinter的博客-优快云博客《深度探索c++对象模型》第三章笔记:《深度探索c++对象模型》第三章笔记_StudyWinter的博客-优快云博客《深度探索c++对象模型》第四章笔记:《深度探索c++对象模型》第四章笔记_StudyWinter的博客-优快云博客《深度探索c++对象模型》第五章笔记:《

StudyWinter的博客 617

【专栏目录】

🌟 深度学习工程师的终极武器库!本专栏深度解析近3年CV领域最前沿的YoloV8改进方案,每一种方法都经过实战验证,性能显著提升!🌟。

m0_47867638的博客 1万+

《深度探索C++对象模型》笔记目录

读书笔记,特此记录。 😇😇😇 《深度探索C++对象模型》阅读笔记 第一章 关于对象 《深度探索C++对象模型》阅读笔记 第二章 构造函数语意学 《深度探索C++对象模型》阅读笔记 第三章 Data语意学 《深度探索C++对象模型》阅读笔记 第四章 Function语意学 《深度探索C++对象模型》阅读笔记 第五章 构造、解构、拷贝语意学 《深度探索C++对象模型》阅读笔记 第六章 执行期语意学 《深度探索C++对象模型》阅读笔记 第七章 站在对象模型的尖端...

哇咔咔的博客 364

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

《深度探索C++对象模型》笔记

本文深入探讨C++对象模型及其底层实现机制,重点分析了虚函数、继承与虚继承对内存布局的影响。文章在64位MSVC环境下,通过具体代码示例展示了类对象的内存结构:非静态数据成员存储在对象内,静态成员和函数存放在对象外;虚函数通过虚函数表实现动态绑定,派生类会扩充修改基类虚函数表;虚继承通过虚基类表解决多继承问题,共享基类子对象。测试数据表明,虚继承会导致更复杂的对象模型,涉及多个虚指针和数据分隔。文章强调对象起始地址对this指针和成员调用的关键影响,为理解C++底层机制提供了重要参考。

Coolbike的博客 913

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

《深度探索c++对象模型》第七章笔记

这一章讨论三个著名的C++语言扩充性质,它们都会影响CH+对象。它们分别是 template、exception handling (EH)和runtime type identification (RTTI)模版、异常、通过运行时类型识别。

StudyWinter的博客 563

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

《深度探索C++对象模型》阅读笔记 第七章 站在对象模型的尖端

然而,member functions(至少对于那些未被使用过的)不应该被“实例化”。只有在member functions被使用的时候,C++ Standard才要求它们被“实例化”。目前的编译器并不精确遵循这项要求。之所以由使用者来主导“实例化”(instantiation)规则,有两个主要原因:可以明确的要求在一个文件中将整个类模板实例化: 也可以显示指定实例化一个模板类的成员函数: 或是针对一个模板函数: 模板的错误报告,使用模板并遇到错误的大概都深有体会,那就是一个灾难。所以在一个parsing策

哇咔咔的博客 691

《深度探索C++对象模型》随笔

深度探索C++对象模型随笔第一章 关于对象第二章第三章第四章第五章第六章第七章 第一章 关于对象   1. C++中,有两种数据成员:     ①静态数据成员②非静态数据成员   三种成员函数:     ①静态成员函数②非静态成员函数③虚函数      2. 静态数据成员放在类之外,非静态数据成员被配置与每一个类对象之类   静态和非静态成员函数也放在类之外,虚函数则是特殊情况:     ①每个类产生一堆指向其虚函数的指针,集合在一个表格中,该表成为虚函数表(vtbl)     ②每个类对象被安插一个指针,

qq_43082206的博客 388

《深度探索C++对象模型》读书笔记-第七章

第七章 站在对象模型的类端 Template 模板是c++支持参数化多态的工具,使用模板可以使用户为类或者函数声明一种一般模式,使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。因此可以说,模板是一种对类型进行参数化的工具。 template<class T> 和template<typename T>都可以用来定义函数模板和类模板,在使用上,他们俩没有本质的区别。 函数模板针对仅参数类型不同的函数;类模板针对仅数据成员和成员函数类型不同的类。 Note...

Estelle 325

C++对象模型笔记:概述

本系列文章是对Lippman的《深度探索c++对象模型》(“Inside the c++ object model”)的读书笔记。1、关于作者Lippman:c++首个编译器的开发者之一,所作的c++方面的书籍有:《c++ primer》:c++的百科全书,和c++之父的《c++ programming language》齐名。《Inside the c++ object model》:讲述c++

jiangnanyouzi的专栏 1472

深度探索C++对象模型笔记 —— 第七章

Point< float >* ptr=0; 程序中什么都没发生,因为一个指向class object的指针,本身并不是一个class object,编译器不需要知道与该class有关的任何members的数据或object布局数据,所以将一个“Point的一个float实例”实例化也就没有必要了 如果是引用呢,假设const Point< float >&ref...

pengfeisusjtu的博客 251

《深度探索C++对象模型》读书笔记第七章:站在对象模型的尖端

模板: 对于类来说,只有成员函数在被使用的时候,才会被具现出来。之所以如此,主要有两个原因: 空间和事件的考虑。可能只使用少数成员函数,不需要具现全部。尚未实现的机能。并不是一个 template 具现出来的所有类型一定能够完整支持一组成员函数所需要的运算符。如果只具现真正用到的成员函数,编译器就能够支持哪些对于其他成员函数可能造成编译错误的类型。(比如T t = 1024,t 或

FreeeLinux's blog 565

深度探索C++对象模型读书笔记-第七章站在对象模型的尖端

Template 模板是在编译时期而非执行时期被计算的。因此其不会带来效率的降低。 1: const Pointfloat> &ref = 0; 该语句会实例化一个Point的float实例。该语句会被扩展为: 1: Pointfloat> temp(float(0)); 2: const Pointfloat> &ref = temp;

fox1987的专栏 1000

[读书笔记] 深入探索C++对象模型-第七章-站在对象模型的尖端(下)

整理本系列笔记的最后一篇,关于运行时类型信息(RTTI)。保证安全的向下转型向下类型转换:是指由父类向子类的类型转换,由于父类信息少于子类,所以通常来说,没有特殊机制支持的话,这种转换是不安全的,要支持此机制的话,在空间和时间上都需要额外的负担: 1. 空间上,需要额外的空间存储类型信息,通常是一个指针,指向某个类型信息节点。 2. 时间上,需要额外的时间,已决定执行期的类型。 一种主流的策略

beyongwang的博客 588

深度探索C++对象模型 学习笔记 第七章 站在对象模型的尖端(1)

在本章中,我将讨论三种对 C++ 对象模型影响深远的语言扩展:模板(templates)、异常处理(exception handling, EH)和运行时类型识别(runtime type identification, RTTI)。EH(以及 RTTI,它在某种意义上可视为 EH 的副产品)与我在此讨论的其他特性有所不同——因为我从未有机会真正实现它。因此,我的讨论将主要依据 [CHASE94]、[LAJOIE94a]、[LAJOIE94b]、[LENKOV92] 和 [SUN94a]。7.1 Templ

tus00000的博客 172

《深度探索C++对象模型》笔记(7)

instatiation 实例化、实现 template模板、exception handling(EH)异常处理、runtime type identification(RTTI)执行期类型识别 第七章 站在对象模型的尖端 Template模板 Point< float >* ptr=0; 不会扩展 const Point< float >& r...

coologic 194
上一篇: 深度探索C++对象模型-----第一章笔记
下一篇: C语言深度解剖----重点部分笔记
Parallel2333
博客等级 码龄10年 40粉丝 51原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值