#include <iostream>

using namespace std;

class BB {

public: //

    BB() { }                          //无参构造函数

    BB (int a)   { Pub_mem = a; }     //有参构造函数     

//普通成员函数

    void printC() {

        cout<<"c:"<<Pri_Static_mem<<endl;

    }

    void AddC() {

        Pri_Static_mem = Pri_Static_mem + ;

    }    

public:

    static void getC() { //静态成员函数

        cout<<"静态成员函数 c:"<< Pri_Static_mem <<endl;

        /**

         *  静态函数中 不能使用 普通和静态(私有/公有)成员变量

         *  静态函数中 不能使用 普通和静态(公有)成员函数, 但可以使用 静态(私有)成员函数

         */

//         cout<<"a:"<<a<<endl; //error C2597: 对非静态成员“BB::a”的非法引用

//         cout<<"mem:"<<Pub_mem<<endl; //error C2597: 对非静态成员“BB::Pub_mem”的非法引用

//         printC();//error: cannot call member function ‘void BB::printC()’ without object

        Private_Static_func();

    }

private:

    static void Private_Static_func(){

        //

    }

public:

    int Pub_mem;                  //公有数据成员

    static int Pub_Static_mem;    //公有静态数据成员    

private:

    int a;            //私有数据成员

    int b;            //私有数据成员

    static int Pri_Static_mem;     //私有静态成员变量

protected:

};

/*  如果使用了静态变量:一定要注意初始化!!!!   */

int BB::Pri_Static_mem = ;           //声明与定义 静态数据成员变量  初始值为10  [私有]

int BB::Pub_Static_mem = ;            //声明与定义 静态数据成员变量  初始值为1   [公有]

int main(void) {

/*--------------------------------------------------------------

    私有静态数据变量：只能调用函数进行访问

--------------------------------------------------------------*/

    BB b1, b2, b3;

    b1.printC(); //

    b2.AddC(); //

    b3.printC(); //11

    //私有/公有静态成员变量/函数的调用方法   对象.    类::

    b3.getC();

    BB::getC();

    cout<<"hello..."<<endl;

/*--------------------------------------------------------------

    公有静态数据变量: 可以直接调用该变量进行修改

--------------------------------------------------------------*/

    BB cs(); //mem = 7  初始化

    for(int i = ; i < ; i++) {

        BB::Pub_Static_mem += i ;

        cout << BB::Pub_Static_mem << '\t' ;

    }

    cout<<endl;

    return ;

}

#include <iostream>

using namespace std;

class A

{

public:

    //友元类B

    friend class B;

    //1 声明的位置 和 public private没有关系

    //2 函数modifyA 是 类A的好朋友

    friend void modifyA(A *pA, int _a); 

    A(int a=, int b=)

    {

        this->a = a;

        this->b = b;

    }

    int getA()

    {

        return this->a;

    }

private:

    int a;

    int b;

};

void modifyA(A *pA, int _a)

{

    pA->a = _a;

}

//若B类是A类的友员类，则

//  在B类的所有成员函数都是A类的友员函数

//  在B中可以访问A类的私有成员 私有函数

//友员类通常设计为一种对数据操作或类之间传递消息的辅助类

class B

{

public:

    void Set(int a)

    {

        Aobject.a = a;

    }

    void printB()

    {

        cout<<Aobject.a <<endl;

    }

private:

    A Aobject;

};

int main(void)

 {

/* 友元函数 */

    A a1(, );

    cout<< a1.getA()<<endl;

    modifyA(&a1, );

    cout<< a1.getA()<<endl;

/* 友元类 */

    B b1;

    b1.Set();

    b1.printB();

    cout<<"hello..."<<endl;

    return ;

}