c-14 c++ 类函数和普通函数的区别

电玩女神 2022-11-29 11:29 183阅读 0赞

### 文章目录 ###

*  隐含this指针
 *  常函数

--------------------

# 隐含this指针 #

#include<stdio.h>
    #include<iostream>
    using namespace std;
    using std::cout;
    
    class MyClass
    {
        
    public:
    	//故意声明不实现
    	void myFun(int n);
    
    };
    int main() {
        
    	MyClass my ;
    	my.myFun(3);
    	getchar();
    	return EXIT_SUCCESS;
    }

由于`myFun`只声明不实现，所以在链接阶段会有错误抛出，在`VS2015`下输出:  
`1>MYC.obj : error LNK2019: 无法解析的外部符号 "public: void __thiscall MyClass::myFun(int)" (?myFun@MyClass@@QAEXH@Z)，该符号在函数 _main 中被引用`

我们看到类函数的调用约定为`__thiscall`，而不是我们常见的`__cdecl`。  
根据微软的官方说明：  
`__thiscall`:

> Under \_\_thiscall, the callee cleans the stack, which is impossible for vararg functions. Arguments are pushed on the stack from right to left. The this pointer is passed via register ECX, and not on the stack.

背调方清理堆栈，隐含`this`参数通过`EXC`寄存器传入，其他参数通过堆栈，入参从右到左。  
由于类函数隐含了`this`参数所以我们可以在类函数内部访问各种私有属性，都是同过这个隐含参数完成的。（传入的`this`类型为`type* const` ）

#include<stdio.h>
    #include<iostream>
    using namespace std;
    using std::cout;
    
    class MyClass
    {
        
    
    private:
    	int age = 23;
    public:
    	void  myFun(int n) {
        
    		//通过隐含的this来修改age
    		//等价于如下代码
    		// MyClass *p = this;
    		//p->age=23
    		age = 23;
    		//由于this 是MyClass * const this 类型 ，所以无法更改age
    		//this.age = 23;
    	}
    };
    
    int main() {
        
    	MyClass my ;
    	my.myFun(3);
    	getchar();
    	return EXIT_SUCCESS;
    }

我们查看vs寄存代码验证`__thiscall`的一些论证：  
`this参数会放入EXC寄存器:`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]

[微软\_\_thiscall 说明][thiscall]

# 常函数 #

class Person {
        
    public:
        int arg = 30;
        Person() {
        
            cout << "Person()" << endl;
        }
        Person(int i) : arg(i) {
        
            cout << "Person(int)" << arg << endl;
        }
        int GetArg() {
        
            return arg;
        }
    
        int SetArg(int arg) {
        
            this->arg = arg;
        }
    };
    int main() {
        
        //定义一个常量 只读
        const Person person(15);
        //此时我们想读取arg属性。由于只读所以不影响变量可读
        //很可惜编译报错了。
        int arg = person.GetArg();
        return 0;
    }

为了避免上述编译调用只读函数出错，所以我们可以在`GetArg`添加`const`关键使其变为常函数(常函数内部禁止修改this内容)。

int GetArg() const {
        
            return arg;
        }

为什么`GetArg`不加`const`会报错？  
因为由于`常函数`和`非常函数`的this类型不同。

常函数传入`this`指针类型为`const Person const * this`。  
而非常函数`this`指针类型为`const Person * this`。

有了上面的结论我们再回头看下代码：

int main() {
        
        //定义一个常量只读,所以此处所有调用成员函数时会传入const Person const * this
        //而最原始的GetArg函数 由于非常函数，所以导致类型不符合才无法调用。
        const Person person(15);
        //此时我们想读取arg属性。由于只读所以不影响变量可读
        //很可惜编译报错了。
        int arg = person.GetArg();
        return 0;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/5ad57bf8b08342968fd4449dd5634e87.png
[thiscall]: https://docs.microsoft.com/en-us/cpp/cpp/thiscall?view=vs-2019