C/C++编程：成员函数的调用方式

迈不过友情╰ 2023-01-18 09:20 4阅读 0赞

# 引入 #

问题：对于Point3d指针和对象的函数调用

Point3d obj
    Point3d *ptr = &obj;
    
    obj.normalize();
    ptr->normalize();

会发生什么事情呢？其中normalize()定义如下：

Point3d Point3d::normalize() const{
        
    	float mag = magnitude();
    	Point3d normal;
    	normal._x = _x/ mag;
    	normal._y = _y/ mag;
    	normal._z = _z/ mag;
    	return normal;
    }
    
    float Point3d::magnitude() const{
        
    	return sqrt(_x*_x + 
    	            _y*_y + 
    	            _z * _z);
    }

回答：不知道

*  C++支持三种类型的成员函数：静态、非静态、虚函数，每一种类型的调用方式都不同
 *  上面normalize()和magnitude()不确定是不是虚函数或者非静态，但可以确定它一定不是静态，原因如下：
    
     *  它直接存取非静态数据
     *  它被声明为const

# 非静态成员函数 #

C++的设计准则之一就是：**非静态成员函数至少必须和一般的非成员函数有相同的效率**。

也就是说，对于选择：

float magnituude3d(const Point3d *_this) {
        }
    float Point3d::magnitude3d()const {
        }

那么选择成员函数和非成员函数的效率是一样的。**这是因为编译器内部已经将`成员函数实体`转换为对应的`非成员函数实体`**

虽然**非成员函数**看起来比较没有效率：它间接的经由参数取用坐标成员，而成员函数直接取用坐标成员。实际上成员函数会被内化为非成员的形式。步骤如下：

float magnituude3d(const Point3d *_this) {
        
    	return sqrt(_this->_x*_this->_x + 
    	            _this->_y*_this->_y + 
    	            _this->_z * _this->_z);
    }

*  改写函数原型以安插一个额外的参数到成员函数中，用以提供一个存取管道，使类成员得以调用该函数。该额外参数被称为this指针：

//非const非静态成员的增长过程
    Point3d Point3d::magnitude(Point3d *const this);

如果成员函数是const，则变成：

//const非静态成员的增长过程
    Point3d Point3d::magnitude(const Point3d *const this);

*  将每一个对**非静态数据成员**的存取操作，改为由**this指针**来存取

{
        
    return sqrt(this->_x*this->_x + 
    	        this->_y*this->_y + 
    	        this->_z * this->_z);
    }

*  将成员函数重新写成一个外部函数，对函数名称进行`mangling`处理，使它在程序中称为独一无二的词汇：

extern magnitude_7Point3dFv(Point3d *const this);

现在程序已经被转换好了，而其每一个调用操作也都必须转化：

//obj.normalize();
    magnitude_7Point3dFv(&obj);
    
    //ptr->normalize()
    magnitude_7Point3dFv(ptr);

对于normalize()将会转换为下面的形式：

void normalize__7Point3dFv(const Point3d *const this, Point3d &_result){
        
    	float mag = this->magnitude();
    	
    	//默认拷贝函数
    	__result.Point3d::Point3d();
    
    	__result._x = this->_x / mag;
    	__result._y = this->_y / mag;
    	__result._z = this->_z / mag;
    	
    	return;
    }

一个比较有效率的做法是直接构建`normal`值：

Point3d Point3d::normalize() const{
        
    	float mag = magnitude();
    	return Point3d(_x/mag, _y/mag, _z/mag);
    }

将会被转换为：

void normalize__7Point3dFv(const Point3d *const this, Point3d &_result){
        
    	float mag = this->magnitude();
    	
    	__result.Point3d::Point3d( 
    	        this->_x / mag,
    	    	this->_y / mag,
    	    	this->_z / mag);
    
    	return;

这可以节省默认构造函数初始化所引起的额外负担

# 虚成员函数 #

## 通过指针调用 ##

如果`normalize()`是一个**虚成员函数**，那么：

ptr->normalize();

将会转化为：

(*ptr->vptr[1])(ptr);

其中：

*  `vpt`·表示由编译器产生的指针，指向**虚函数表**。它被安插在每一个**声明有(或者继承)一个或者多个虚函数**的**类对象**中。事实上，其名称也会被`mangled`，因为在一个复杂的派生类中，可能存在多个vptrs
 *  1是vritual table slot的索引值，关联到`normalize()`函数
 *  第一个`ptr`表示this指针

同样，如果`magnitude()`也是一个虚函数，它在normalize()中的调用操作将转换为：

// float mag = magnitude();
    float float mag = (*this->vptr[2])(this).

此时，由于Point3d::magnitude()是在Point3d::normalize()中被调用，而后者已经由虚拟机制而决议完成，所以**明确调用Point3d会更有效率**（如下），并因此压制由于虚拟机制而产生的不必要的重复调用机制：

//（使用类作用域操作符）明确的调用操作会压制虚拟机制
    float mag = Point3d::magnitude();

如果magnitude()声明为**内联函数**会更有效率。使用类作用域操作符明确调用一个虚函数，其决议方式和非静态成员函数一样。也就是说上面会转换为：

// float mag = Point3d::magnitude();
    float mag = magnitude_7Point3dFv(this);

## 通过类对象调用 ##

**由类对象调用一个虚函数**，这种操作总是被编译器像对象一个一般的非静态成员函数一样的加以决议：

// Point3d obj;
    
    // obj.normalize();
    normalize_7Point3dFv(&obj);

# 静态成员函数 #

如果Point3d::normalize()是一个静态成员函数，以下两个调用操作：

obj.normalize();
    ptr->normalize();

将会转换为一般的非成员函数调用：

// obj.normalize();
    normalize_7Point3dFv();
    //ptr->normalize();
    normalize_7Point3dFv();

## 为什么要引入非静态成员函数 ##

*  在引入非静态成员函数之前，C++语言要求是由的**成员函数**必须由**类对象**调用
 *  实际上，只有当**成员函数**中用到了**非静态数据**时，此需要用到**类对象**
 *  **类对象**提供了this指针给这种形式的函数调用使用。这个this指针把**成员函数中的非静态类成员**绑定在**类对象对应的成员**上。
 *  如果成员函数中没有用到非静态数据成员，也就需要this指针，从而也就没有必要通过一个**类对象**来调用一个**成员函数**

这样一来存取**静态数据成员**时产生了一些不规则性：

*  如果**非静态数据成员是nonpublic**(事实上常常是)，那么这里类就必须提供一个或者多个**成员函数**来存取该成员。
 *  这时，虽然你可以不靠类对象来存取一个静态成员，但其存取函数必须绑定到一个**类对象**上

为了解决这个矛盾，C++引入了**静态成员函数**，静态成员函数的主要特性**它没有this指针**。以下次要特性都根源于其主要特性：

*  它不能直接存取类中的**非静态成员**
 *  它不能被声明为const、volatile、virtual
 *  它不需要经由类对象才被调用

如果取一个静态成员函数的地址，获得的是其在内存中的位置，也就是其地址。由于静态成员函数没有this指针，所以其地址的类型并不是一个`指向类成员函数的指针`，而是一个`非成员函数指针`。也就是说：

&Point3d::object_count();

会得到一个数值，其类型是：

unsigned int (*)();

而不是：

unsigned int (Point3d::*)();

静态成员函数由于缺少this指针，因此差不多相当于非成员函数。它可以作为一个回调函数使用