c/c++整理--c++面向对象（2）

一、看代码写结果——c++类成员的访问

    <span style="font-size:18px;">#include <iostream>  
      
    using namespace std;  
      
    #define public private<span style="white-space:pre;">       </span>(1)  
      
    class Animal  
    {  
    public:<span style="white-space:pre;">              </span>(2)  
        void MakeNoise();  
    };  
      
    int main()  
    {  
        Animal animal;  
        animal.MakeNoise();<span style="white-space:pre;">  </span>(3)  
      
        return 0;  
    }</span>  

（1）正确。把public宏定义为private。

（2）正确。定义public成员。注意：由于public已经被定义为private，因此这里的MakeNoise()成员函数实际上是private的。

（3）错误。对象不能访问类的私有成员函数

二、类成员的初始化

找错

    <span style="font-size:18px;">#include <iostream>  
      
    using namespcae std;  
      
    class Obj{  
        int i, j;  
    public:  
        Obj(int k) : j(k), i(j)  
        {  
        }  
        void print()  
        {  
            cout<<i<<endl<<j<<endl;  
        }  
    };  
      
    int main()  
    {  
        Obj obj(2);  
        obj.print();  
    }</span>  

这里初始化顺序与变量声明顺序一致，而不是按照出现在初始化列表中的顺序。这里i在j之前声明，所以构造时i也是在j之前被初始化，所以第8行先执行i（j），这时j的值为随机值，故i的值也是随机值，然后执行j（k），所以j为2.

三、看代码写结果——静态成员变量的使用

<span style="font-size:18px;">#include <iostream>  
  
using namespace std;  
  
class Myclass  
{  
public:  
    Myclass(int a, int b, int c);  
    void GetNumber();  
    void GetSum();  
private:  
    int A;  
    int B;  
    int C;  
    int Num;  
    static int Sum;  
};  
  
int Myclass::Sum = 0;  
  
Myclass::Myclass(int a, int b, int c)  
{  
    A = a;  
    B = b;  
    C = c;  
    Num = A+B+C;  
    Sum = A+B+C;  
}  
  
void Myclass::GetNumber()  
{  
    cout<< "Number = " << Num << endl;  
}  
  
void Myclass::GetSum()  
{  
    cout<< "Sum = " << Sum << endl;  
}  
  
int main()  
{  
    Myclass M(3, 7, 10), N(14, 9, 11);  
    M.GetNumber();  
    N.GetNumber();  
    M.GetSum();  
    N.GetSum();  
  
    return 0;  
}</span>

静态成员被当做该类型的全局变量。对于非静态变量，每个类对象都有自己的复制品，而静态成员对每个类的类型只有一个复制品。静态成员只有一份，由该类类型共享。