C++学习二 ：static关键字、const关键字、友元函数、友元成员函数、友元类

一.static关键字

1.C语言中static的用法

    static修饰局部变量:延长局部变量的生命周期

    static修饰全局变量:限制了全局变量的作用域 只能在本文件中使用

    static修饰函数: 限制了函数的作用域 只能在本文件中使用函数

2.C++中static的用法

    1)static成员变量

        eg:     

      class Demo{

            public:

                Demo(int v) : val(v)//构造函数

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

                ~Demo()//析构函数

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

            public:

                void setval(int val)

                {

                    this->val = val;

                }

                int getval()

                {

                    return this->val;

                }

                static int getsval()//static成员方法：static成员变量必须通过static成员函数访问才合适
                {

                    return sval;

                }

                static int *getaddr()

                {

                    return &sval;

                }

            private:

                int val; //成员变量

                static int sval;//static成员变量:与对象无关  所有类对象共享static成员

        };

        int Demo::sval = 123;//static成员变量必须在类外部声明定义初始化

        int main()

        {

            Demo obj(666);//构造对象

            Demo obj1(888);//构造对象

            //cout << sizeof obj << endl;

            cout << obj.getsval() << endl;

            cout << obj1.getsval() << endl;

            cout << obj.getaddr() << endl;//所有类对象共享static成员

            cout << obj1.getaddr() << endl;

            cout << Demo::getsval() << endl;

            cout << Demo::getaddr() << endl;

            return 0;

        }

总结：

    1)static成员变量必须在类外部声明定义初始化

    2)static成员与对象无关 是所有对象的其享成员

    3)static成员变量应该通过static成员函数访问

    4)static成员函数的访问：类名::成员方法

    5)static成员函数没有this指针

二.const关键字

1.C中const的用法

    1)const修饰变量：

                只读变量 只能初始化，不能修改

        eg:

            const int i = 123;

            i = 321;//error

    2)const修饰指针

        eg:

            int i = 123;

            const int *p = &i;//等价: int const *p = &i; 不能通过指针修改指针指向的内容

            int * const p  =&i;//指针的指向不能改

            const int * const p = &i;//既不能通过指针修改指针指向的内容，也不能那个修改指针的指向

2.C++中const的用法

    1)const修饰成员变量

        eg:

            class Demo{

            public:

                Demo(int val, int cval) : val(val),cval(cval) //构造函数:对const成员变量进行初始化

                {

                    //this->cval = 123;//error  const成员变量只能被初始化，不能被修改

                    cout << __func__ << ":" << __LINE__ << endl;

                }

                ~Demo()//析构函数

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

            public:

                void setval(int val)

                {

                    this->val = val;

                }

                int getval()

                {

                    return this->val;

                }

                int getcval()

                {

                    return this->cval;

                }

                static int getsval()

                {

                    return sval;//static成员函数没有this指针

                }

                static int *getaddr()

                {

                    return &sval;

                }

            private:

                int val; //成员变量

                const int cval; //const成员变量:只能初始化 不能修改

                static int sval;//static成员变量:与对象无关  所有类对象共享static成员

        };

        int Demo::sval = 123;//static成员变量必须在类外部声明定义初始化

        int main()

        {

            Demo obj(666,888);//构造对象

            cout << sizeof obj << endl;

            cout << obj.getcval() << endl;

            return 0;

        }

    2)const成员函数

        结论：

            const方法是不能修改类对象

            const方法可以修改static成员，因为static不属于类对象

            const方法不能调用非const方法,非const方法有可能回修改到类对象

            const方法是允许调用const方法，const方法本身不会修改到类对象

   

        eg:           

class Demo{

            public:

                Demo(int val, int cval) : val(val),cval(cval) //构造函数:对const成员变量进行初始化

                {

                    //this->cval = 123;//error  const成员变量只能被初始化，不能被修改

                    cout << __func__ << ":" << __LINE__ << endl;

                }



                ~Demo()//析构函数

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

            public:

                void setval(int val)

                {

                    this->val = val;

                }



                int getval() const //const成员函数不能修改类对象

                {

                    //val++;//error const方法是不能修改类对象

                    sval++;//right  static成员不属于类对象

                    //setval(123);//const方法不能调用非const方法

                    getcval();//const方法是允许调用const方法



                    return this->val;

                }



                int getcval() const //const成员方法

                {

                    return this->cval;

                }



                static int getsval()

                {

                    return sval;//static成员函数没有this指针

                }



                static int *getaddr()

                {

                    return &sval;

                }



            private:

                int val; //成员变量

                const int cval; //const成员变量:只能初始化 不能修改

                static int sval;//static成员变量:与对象无关  所有类对象共享static成员



        };



        int Demo::sval = 123;//static成员变量必须在类外部声明定义初始化



        int main()

        {

            Demo obj(666,888);//构造对象

            cout << sizeof obj << endl;

            cout << obj.getcval() << endl;



            return 0;

        }

    3)const对象

        特点：对象是只读的，即对象不能背修改

        总结：

            const对象只能调用const方法

       

        eg:           

 class Demo{

            public:

                Demo(int val, int cval) : val(val),cval(cval) //构造函数:对const成员变量进行初始化

                {

                    //this->cval = 123;//error  const成员变量只能被初始化，不能被修改

                    cout << __func__ << ":" << __LINE__ << endl;

                }



                ~Demo()//析构函数

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

            public:

                void setval(int val)

                {

                    this->val = val;

                }



                int getval() const //const成员函数不能修改类对象

                {

                    //val++;//error const方法是不能修改类对象

                    sval++;//right  static成员不属于类对象

                    //setval(123);//const方法不能调用非const方法

                    getcval();//const方法是允许调用const方法



                    return this->val;

                }



                int getcval() const //const成员方法

                {

                    return this->cval;

                }



                static int getsval()

                {

                    return sval;//static成员函数没有this指针

                }



                static int *getaddr()

                {

                    return &sval;

                }



            private:

                int val; //成员变量

                const int cval; //const成员变量:只能初始化 不能修改

                static int sval;//static成员变量:与对象无关  所有类对象共享static成员



        };



        int Demo::sval = 123;//static成员变量必须在类外部声明定义初始化



        int main()

        {

            const Demo obj(666,888);//const对象：对象是只读的，不能被修改

            cout << sizeof obj << endl;

            cout << obj.getcval() << endl;//const对象可以调用const方法



            //obj.setval(123);//error const对象不能调用非const方法



            return 0;

        }

三.友元函数

1.理解：

    指:普通函数是类的友元(朋友)

    eg:       

 class Demo{
        public:
            Demo(int val) : val(val)
            {
                 cout << __func__ << ":" << __LINE__ << endl;
            }
            ~Demo()
            {
                 cout << __func__ << ":" << __LINE__ << endl;
            }
        public:
            int getval() const;
            friend void setval(Demo &,int) ;//友元函数
        private:
            int val;
        };
        int Demo::getval() const
        {
            return this->val;
        }
        void setval(Demo &obj,int val) //普通函数
        {
            obj.val = val;
        }
        int main()
        {
            Demo obj(666);
            setval(obj,123);//友元函数的调用
            cout << obj.getval() << endl; 
            return 0;
        }

    

四.友元成员函数

1.理解

    一个类的成员函数是另外一个类的友元

    eg:

        class A;//前项声明

        class B{

            public:

                B()

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

                ~B()

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

            public:

                void setval(A &, int);

        };
     

  class A{
            public:
                A(int val = 0) : val(val)
                {
                   cout << __func__ << ":" << __LINE__ << endl;
                }
                ~A()
                {
                    cout << __func__ << ":" << __LINE__ << endl;
                }
                int getval() const
                {
                    return this->val;
                }
                friend void B::setval(A &, int);//友元成员函数: 类B的成员函数setval是类A的友元
            private:
                int val;
        };
        void B::setval(A &obj, int val)
        {
            obj.val = val;
        }
        int main()
        {
            A obja(123);
            B objb;
            objb.setval(obja, 666);
            cout << obja.getval() << endl;
            return 0;
        }

五.友元类

1.理解

    指一个类作为另外一个类的友元

   

    eg:

        class A;//前项声明

        class B{

            public:

                B()

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

                ~B()

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

            public:

                void setval(A &, int);

        };

class A{
            public:
                A(int val = 0) : val(val)
                {
                    cout << __func__ << ":" << __LINE__ << endl;
                }
                ~A()
                {
                    cout << __func__ << ":" << __LINE__ << endl;
                }
                int getval() const
                {
                    return this->val;
                }
                friend class B;//友元类: 类B是类A的友元
            private:
                int val;
        };
        void B::setval(A &obj, int val)
        {
            obj.val = val;
        }
        int main()
        {
            A obja(123);
            B objb;
            objb.setval(obja, 666);
            cout << obja.getval() << endl;
            return 0;
        }

       

       

总结：

    1)友元关系不能继承

    2)友元关系不具有交换性

    3)友元关系不具有传递性

注意：

    友元不是成员