关于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(,);            

int* p = (int*)&t;
int n = *p;
int m = *(p+);
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 = ;
    base.y = ;        

    return ;
}            

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 = ;  //无法访问
    sub.y = ;  //无法访问
    sub.a = ;
    sub.b = ;        

    return ;
}            

父类中的程序继承后变成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 = ;
        y = ;
    }
private:
    int x;
    int y;
};   

class Sub:Base
{
public:
    int a;
    int b;
};            

int main(int argc, char* argv[])
{
    Sub sub;
    sub.a = ;
    sub.b = ;        

    int* p = (int*)⊂        

    printf("%d\n",sizeof(sub));
    printf("%d\n",*(p+));
    printf("%d\n",*(p+));
    printf("%d\n",*(p+));
    printf("%d\n",*(p+));        

    return ;
}