c++类定义与继承

#include<stdio.h>
#include<iostream>
#include<string>
using namespace std;
class A{
    int m_b;//前面没有级别声明则默认为私有成员
public:
    void SetA(int a, int b,int d){
        m_a = a; //类内部可以访问私有成员m_a;
        m_b = b;
        m_d = d;
    }
    int m_c; // 公有成员，类里类外均可以访问
private:
    int m_a;
protected:
    int m_d;
};
class B:public A{
public:
    void SetB(){
        SetA(1,2,3);// 基类公有成员作为派生类公有成员
    //    m_a = 7;//error C2248: 'm_a' : cannot access private member declared in class 'A'
        //任何继承方式的继承都不能访问基类私有成员
        m_d = 5; // 基类保护成员在派生类中仍然是保护成员，可以访问。
    }
};
class C:protected A{
    void SetC(void){
        SetA(4,5,6); //protected能访问基类公有成员
        m_d = 1; //保护继承能访问基类保护成员
    //    m_a = 4; // 保护继承不能访问基类私有成员
    }
};
class D:private A{
    void SetD(void){
        SetA(4,5,6); //私有继承派生类能访问基类公有成员
        m_d = 1; //私有继承派类能访问基类保护成员
        //m_a = 4; // 保护继承不能访问基类私有成员
    }
};
/*void A::SetA(int a,int b){
    m_a = a;
    m_b = b;
}*/
int main(){
    A a;
    B b;
    C c;
    D d;
    a.SetA(1,5,6);
    b.m_c = 9;//B是公有继承，在公有成员在派生类中仍然作为公有成员
//    c.m_c = 9; //C是保护继承，在公有成员变量在派生类中为保护成员变量，对象不能访问。
    //d.m_c = 1; // D是私有继承，基类中公有成员变量在派生类中为私有成员变量，对象均不能访问。
    //b.m_d = 4; // 不管公有继承还是保护继承，基类中保护继承均在派生类中为保护成员，对象均不能访问。
//    b.m_b = 7; //: error C2248: 'm_b' : cannot access private member declared in class 'A'
       // F:\C information\getnumofcolumn.cpp(7) : see declaration of 'm_b'
//    c.m_d = 0;//F:\C information\getnumofcolumn.cpp(30) : error C2248: 'm_d' : cannot access protected member declared in class 'A'
      // F:\C information\getnumofcolumn.cpp(18) : see declaration of 'm_d'
    // 对象不能访问保护成员和私有成员
    return 0;
}

类成员包括成员函数和数据成员。
类的成员属性：公有和私有、保护。
类内部可以访问任何成员。
对象只能访问公有成员，不能访问保护成员和私有成员。
派生类不能访问基类私有成员，但是有些时候为了让派生类访问私有成员，所以把部分私有成员作为保护成员，但是对于对象来说，对象不能访问类的私有和保护成员。
根据基类的成员属性是否改变的把继承分为公有继承，保护继承，私有继承。
公有继承：基类原来公有成员和保护成员在派生类中保持不变，即公有的为公有，保护成员仍然为保护成员。保护继承则把基类原来公有成员改为保护成员，基类保护成员仍然为
保护成员。私有继承彻底改变了基类成员属性，原来公有和保护的均变为私有继承。

继承属性的传递：

#include<stdio.h>
#include<iostream>
#include<string>
using namespace std;
class A {
public:
    int m_a;
};
class B:protected A{
};
class C:public B{
};
int main(){
    C c;
    c.m_a;//error C2248: 'm_a' : cannot access public member declared in class 'A'
    return 0;
}

由于类B是保护继承A，则在类B中，则类B中m_a为保护成员，当C公有继承B时，m_a访问控制没有改变，仍为保护成员，所以对于对象c,不能访问类C保护成员。

静态数据成员：

在类前面加上关键字static，这种成员就是类的静态成员。类的静态成员包括静态数据成员和静态成员函数。静态成员和一般成员特殊在于：

静态数据成员属于类，不属于任何对象。无论有多少对象和没有对象，静态成员都只有一份存于公用的内存中，被该类的所有对象共享。静态成员可以是public、private、protected。由于对象不能访问静态成员，那静态成员三个属性有个卵用？在类中声明的静态成员属于引用性说明，并不实际分配内存。当创建对象时，会为对象的数据成员分配存储空间，但是由于静态数据成员不属于任何对象，所以常见对象时候也不为该类的静态数据成员分配存储空间。所以静态数据成员需要在类外进行定义：格式为：类型 类名 ：：静态数据成员名 = 初值;

class A {
public:
    static int m_rate;
};
int A::m_rate = 2;//类外定义静态成员
int main(){
    A a,b,*p;
    p=&a;
    cout<<A::m_rate<<endl;//1
    cout<<a.m_rate<<endl;//2
    cout<<p->m_rate<<endl;//3
    cout<<b.m_rate<<endl;
    return 0;
}

静态数据成员典型应用就是利率，由于利率对于大家来说都是一样的，如果为一般成员的话，那么当要修改利率时每个存款用户都要修改自己利率时很麻烦的，如果为静态变量，为所有用户共享，只需要在类外定义时修改，非常方便。  上述代码中第3行声明利率为类静态成员，第5行定义了利率的值，注意第5行中没有带上关键字static，原因是防止与一般静态变量混淆。注意：程序中对一个静态成员定义只能出现一次。

类的（公有）静态数据成员访问方式有三种方式：

 1、类名：：静态成员名 。  参见代码第9行

 2、对象名.静态成员名。     参见上面代码第10行

 3、对象指针->静态成员名。   参见上面代码第11行

 

上面讲到3种方式为类的公有静态数据成员访问方式，但是对于类私有静态数据成员访问就不能这样显示访问了，如下代码4个错误。而是需要使用静态成员函数来间接访问。

class A {
private:
    static int m_rate;
};
int A::m_rate = 2;//类外定义静态成员
int main(){
    A a,b,*p;
    p=&a;
    cout<<A::m_rate<<endl;//1  cannot access private member declared in class 'A'
    cout<<a.m_rate<<endl;//2
    cout<<p->m_rate<<endl;//3
    cout<<b.m_rate<<endl;
    return 0;
}

注意对类静态数据成员定义仍然可以在类定义，如下代码是没有错误的。

class A {
private:
    static int m_rate;
};
int A::m_rate = 2;//类外定义静态成员
int main(){
    return 0;
}

静态成员函数，同样道理，如果成员函数前面加static关键字，则该成员函数为静态成员函数。静态成员函数与具体对象无关，静态成员函数只能访问静态数据成员，不能访问一般数据成员，也只能调用其它静态数据函数。

对类的静态成员函数的调用形式：

1、  类名：：静态成员函数调用

2、类对象.静态成员函数调用

3、指向类对象的指针  ->静态成员函数调用

同样此时的调用只是对象的类型，与具体对象无关。

#include<stdio.h>
#include<iostream>
#include<string>
using namespace std;
class A {
public:
    static void SetRate(int m);
    static int GetRate();
private:
    static int m_rate;
};
int A::m_rate = 2;//类外定义静态成员
void A::SetRate(int m){
     m_rate = m;
}
int A::GetRate(){
    return m_rate;
}
int main(){
    A a,*p,b;
    p = &a;
    a.SetRate(4);
    cout<<a.GetRate()<<endl;
    cout<<p->GetRate()<<endl;
    cout<<A::GetRate()<<endl;
    //cout<<A::m_rate<<endl;//error C2248: 'm_rate' : cannot access private member declared in class 'A'
    return 0;
}