面向过程—面向对象（C++的封装，this）_内存四区_变量生命周期

1、面向对象主要涉及  构造函数、析构函数、虚函数、继承、多态等。

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

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

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

　　C++成员数据：static、nonstatic

　　C++成员函数：static、nonstatic、virtual

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

C++编译器 如何完成 面向对象理论 到 计算机程序的转化？C++如何管理 类、对象以及两者之间关系？

当一个对象 调用  类时，C++编译器 如何区分 是哪个对象调用的哪个方法？

看个栗子：

#include "iostream"
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(itn val){k = val;}
  protected:
  private:  
}    

struct S1
{
       int i;
       int j;
       int k;       
}

struct S2
{
       int i;
       int j;
       int k;  
       static int m;     
}

int main()
{
     printf("C1: %d 
", sizeof(C1));
     printf("C2: %d 
", sizeof(C2));
     printf("S1: %d 
", sizeof(S1));
     printf("S2: %d 
", sizeof(S2));
}

4个值都是12，结论：

属性(普通成员变量) 放在栈中；

静态属性（static variable）放在全局数据区；

方法 （成员函数） 放在代码区。

用this指针区分是哪个对象调用的公用方法，谁调用这个公用方法，就把谁的地址传递给this指针。

C++编译器对普通成员函数的内部处理：添加this指针的面向过程实现

看个栗子：

C++的类：

class Test
{
 private:
        int m1;
 public:
        Test(int i)
        {
             m1 - i;
        }
         int get1()
         {
             return m1;
         }
         static void Print()    //静态成员函数属于整个类，不属于某个变量，没有this指针
         {
             printf("This is class Test. 
");
         }
};
Test a(10);
a.get1();
Test::Print();

对应的面向过程的实现过程。

struct Test
{
        int m1;
};
void Test_initialize(Test *pThis, int i)
     {
          pThis->m1 - i;
     }
int Test_get1(Test *pThis)
    {
          return pThis->m1;
    }
void Test_Print()         
     {
         printf("This is class Test. 
");
     }
};
Test a;
Test_initialize(&a, 10);
Test_get1(&a);
Test_Print();

结论：

1、C++类对象的 成员变量 和 成员函数 是分开存储的。C语言中的内存4区模型仍然有效；

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

3、静态成员函数、静态成员变量属于类。静态成员函数不包含指向具体对象的指针，普通成员函数包含一个指向具体对象的指针。

有关内存四区模型：

内存四区模型:

流程说明
1、操作系统把物理硬盘代码load到内存
2、操作系统把c代码分成四个区
3、操作系统找到main函数入口执行

char*fa()
{
char*pa = "123456";//pa指针在栈区，“123456”在常量区，该函数调用完后指针变量pa就被释放了
 char*p = NULL;     //指针变量p在栈中分配4字节
 p=(char*)malloc(100);//本函数在这里开辟了一块堆区的内存空间，并把地址赋值给p
 strcpy(p, "wudunxiong 1234566");//把常量区的字符串拷贝到堆区
 return p;//返回给主调函数fb()，相对fa来说fb是主调函数，相对main来说，fa(),fb()都是被调用函数
}
char*fb()
{
 char*pstr = NULL;
 pstr = fa();
 return pstr;//指针变量pstr在这就结束
}
void main()
{ 
 char*str = NULL;
 str = fb();
 printf("str = %s
",str);
 free(str);    //防止内存泄露，被调函数fa()分配的内存存的值通过返回值传给主调函数，然后主调函数释放内存
 str = NULL;//防止产生野指针
 system("pause");
}

总结：

1、主调函数分配的内存空间（堆，栈，全局区）可以在被调用函数中使用，可以以指针作函数参数的形式来使用;

2、被调用函数分配的内存空间只有 堆区(指针 所指向的 内存区域) 和 全局区（静态变量 和 常量） 可以在主调函数中使用（返回值和函数参数），而栈区（指针存放的地址）却不行，因为栈区函数体运行完之后这个函数占用的内存编译器自动帮你释放了。