关于class

1.使用#include分离函数的定义与实现

c语言可以在xxx.h中定义函数，然后在xxx.cpp中实现函数；

在需要用到这些函数时，只要用#include引入xxx.h即可，这样就不用将所有代码全部写在一个cpp中；

将函数定义与实现分离，代码会有更好的可读性但不是必须的 ；   

 

xxx.h

struct Test            
{            
    int x;        
    int y;        
    int z;        
            
    void Init(int x,int y,int z);        
    void Function1();        
    void Function2();        
    void Function3();        
};            

 

xxx.cpp

void Test::Init(int x,int y,int z)            
{            
    this->x = x;        
    this->y = y;        
    this->z = z;        
}            
void Test::Function1()            
{            
    printf("Function1:%x\n",x);        
}            
void Test::Function2()            
{            
    printf("Function2:%x\n",y);        
}            
void Test::Function3()            
{            
    printf("Function3:%x\n",z);        
}     

 

特别说明：

    1】xxx.h 只是一个文件，可以是任何的后缀名,如果你愿意，可以叫xxx.exe            

    2】#include 的作用只是把里面的内容复制过来 仅此而已.            

    如：#include "abc.exe"            

    3】xxx.h 与 xxx.cpp并不要求一定同名    

 

分开写函数实现时需要告诉编译器函数属于谁的，余姚在函数名前+类名::        

 

2.访问修饰符public和private

public的意思是，这个成员哪里都可以用，不用担心被修改，所以，一旦发布成public的成员，是不能够改名字的.                            

private的意思是，这个成员只用于内部使用，不要在其他的地方使用.                            

 

总结：

    1】对外提供的函数或者变量，发布成public的 但不能随意改动.                            

    2】可能会变动的函数或者变量，定义成private的 这样编译器会在使用的时候做检测.                            

    3】只有结构体内部的函数才可以访问private的成员.                            

    4】public/private可以修饰函数也可以修饰变量.                            

 

private修饰的成员与普通的成员没有区别 只是编译器会检测.                        

private修饰的成员只有自己的其他成员才能访问 ；                       

例如：强行访问private成员struct Test            {            

private:            
    int x;        
public:            
    int y;        
    void Init(int x,int y)        
    {        
        this->x = x;    
        this->y = y;    
    }        
};            
            
            
Test t;            
t.Init(1,2);            
            
int* p = (int*)&t;            
int n = *p;            
int m = *(p+1);            
printf("%d %d\n",n,m);  

      

3.class和struct

class关键字和struct一样也能用来定义结构；

class Base            
{            
    int x;        
    int y;        
};            
            
int main(int argc, char* argv[])            
{            
    Base base;        
            
    base.x = 10;        
    base.y = 20;        
            
    return 0;        
}            

 

class和struct的区别：

    编译器默认class中的成员为private 而struct中的成员为public ；

 

class的继承：

class Base            
{            
public:            
    int x;        
    int y;        
}; 
           
class Sub:Base            
{            
public:            
    int a;        
    int b;        
}; 
           
int main(int argc, char* argv[])            
{            
    Sub sub;        
            
    sub.x = 1;  //无法访问        
    sub.y = 2;  //无法访问        
    sub.a = 3;        
    sub.b = 4;        
            
    return 0;        
}            
 
 
父类中的程序继承后变成private属性；    
也就是默认：
class Sub:private Base    
{    
public:    
    int a;
    int b;
};    
如果不希望改变成员的属性，需要在继承时声明public：   
class Sub:public Base    
{    
public:    
    int a;
    int b;
};    

 

如果父类class中的成员是private，也是能被继承的；

只是编译器不允许直接访问；

例如：强行访问父类private成员

class Base            
{            
public:            
    Base()        
    {        
        x = 11;    
        y = 12;    
    }        
private:            
    int x;        
    int y;        
};   
         
class Sub:Base            
{            
public:            
    int a;        
    int b;        
};            
            
int main(int argc, char* argv[])            
{            
    Sub sub;        
    sub.a = 1;        
    sub.b = 2;        
            
    int* p = (int*)⊂        
            
    printf("%d\n",sizeof(sub));        
    printf("%d\n",*(p+0));        
    printf("%d\n",*(p+1));        
    printf("%d\n",*(p+2));        
    printf("%d\n",*(p+3));        
            
    return 0;        
}