C++之面向对象初探----对象管理模型（关键是this指针）

前言

c++对象模型可以概括为以下2部分

　　1、语言中直接支持面向对象程序员设计部分，主要涉及如构造函数、析构函数、虚函数、继承（单继承、多继承、虚继承）、多态等待。

　　2、对于各种支持的底层实现机制

　　在c语言中，“数据”和“处理数据的操作（函数）”是分开来声明的，也就是说，语言本身并没有支持“数据和函数”之间的关联性。

　　在c++中，通过抽象数据类型（ADT,全称：abstract data type)，在类中定义数据和函数，来实现数据和函数直接的绑定。

　　概括来说，在c++类中有两种成员数据，static，nonstatic;三种成员函数：static,nonstatic,virtual.

基础知识

c++中的class从面向对象理论出发，将变量（属性）和函数（方法）集中定义在一起，用于描述现实世界的类。从计算机的角度，程序依然由数据段和代码段构成。

c++编译器如何完成面向对象理论到计算机程序的转化？

换句话，c++编译器如何管理类、对象、类和对象之间的关系？

具体的说，具体对象调用类的方法，那，c++编译器是如何区分，是哪个类具体调用了哪个方法的？

下面写段代码思考一下：

#include "iostrem"
using namespace std;
 
class C1
{
public:
     int i;
     int j;
     int k;
protected:
private:
};
 
class C2
{
public:
     int i;
     int j;
     int k;
 
     static int m;
public:
     int getK()const{return k;}
     void setK(int cal){k=cal;}
protected:
private:
}
 
struct S1
{
     int i;
     int j;
     int k;
     static int m;
}
 
int main()
{
     printf("c1:%d\n",sizeof(c1));
     printf("c2:%d\n",sizeof(c2));
     printf("s1:%d\n",sizeof(s1));
     printf("s2:%d\n",sizeof(s2));
}

　　

编译器对属性和方法的处理机制

通过上面的案例，我们可以看出

（1）c++类对象中成员变量和成员函数是分开存储的

成员变量：

　　普通成员变量：存储于对象中，与struct变量有相同的内存布局和字节对齐方式；

　　静态成员变量：存储与全局数据区中。

　成员函数：存储与代码段中。

问题：很多对象共用一块代码？代码是如何区分具体的对象的？

换句话说：int getK()const(return k;},代码是如何区分，具体obj1,obj2,obj3对象的k值的？

答：this指针。

（2）c++编译器对普通成员函数的内部处理。

　　　　C++类　　  　　　　　　　　　　　　　　　　　　　　　　C++类实现机制

class Test { private： int a1; public: Test(int i) { a1=i; } int getI() { return a1; } static void print() { printf("this is class Test.\n"); } };   Test a(10); a.getI(); Test::print();

struct Test { int a1; }   void Test_init(Test*pthis,int i) { pthis->a1 = i; } int Test_getI(Test*pthis) { return pthis->a1; } //静态成员函数没有this指针 void Test_print() { printf("this is struct Test.\n"); }   Test a; Tset_init(&a,10); Test_getI(); Test_print();

总结：

1、C++类对象中的成员变量和成员函数是分开存储的。c语言中的内存

2、C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。

3、静态成员函数、成员变量属于类。

4、静态成员函数与普通成员函数的区别：静态成员函数不包含指向具体对象的指针；普通成员函数包含一个指向具体对象的指针。

this指针

实例：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
 
class Test
{
public:
	Test(int k)
	{
		this->m_k = k;
	}
 
	int getK()  const//成员函数尾部出现const 修饰是this指针
	{
		//this->m_k = 100; //this指针不是 const Test *
		//this++;// this指针是一个常指针， Test *const
		//this->m_k = 100;
		//this = this + 1;
		return this->m_k;
	}
	//static成员函数，只能返回static成员变量
	static int s_getK()
	{
		//return m_k;
		return s_k;
	}
private:
	int m_k;
	static int s_k;
};
int Test::s_k = 0;
int main(void)
{
	Test t1(10); //Test(&t1, 10);
	Test t2(20);
	return 0;
}

　　

 注意：this只能访问类中的非静态成员变量或成员函数。（重中之重）