C++初始化列表，友元详细讲解

最新推荐文章于 2024-06-07 20:11:45 发布

小王的创意工坊

最新推荐文章于 2024-06-07 20:11:45 发布

阅读量338

点赞数 3

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/weixin_52983513/article/details/138413514

版权

初始化列表：

初始化列表特点：

冒号开始，逗号分割

1.初始化列表本质可以理解为每个成员对象中成员定义的地方

具体如下：

#include<iostream>
using namespace std;

//初始化列表
class time
{
public:

        time(int year, int month, int day)
                :_year(year)
                ,_month(month)
                ,_day(day)
        {}


private:
        int _year;
        int _month;
        int _day;
};

2.(const)对象只有在定义的时候可以初始化

//简单理解，例如我们定义一个普通变量
const int a = 10;

//如果像下面这样，是不可以的
const int y;
y=10;
//这种就是定义之后再赋值，是不可以的，会报错

//当然，我们的类中的const对象也是如此。
class Time
{
public:
        Time(int year, int month, int day)
                :_year(year)
                , _month(month)
                , _day(day)
        {}


private:
        int _year;
        int _month;
        int _day;
        const int a = 10;
};

int main()
{
        Time n(1990, 1, 1);
        return 0;
}
//上面这种情况是给一个缺省值，还有一种情况

class Time
{
public:
        Time(int year, int month, int day)
               //定义
                :_year(year)
                , _month(month)
                , _day(day)
                ,a(1)
        {}


private:
    //声明
        int _year;
        int _month;
        int _day;
        const int a;
};

int main()
{
        Time n(1990, 1, 1);
        return 0;
}
//这种情况是在初始化列表中初始我们的const对象

3.引用必须在定义的时候初始化 int& y

class Time
{
public:
        Time(int year, int month, int day,int & rr)
                :_year(year)
                , _month(month)
                , _day(day)
                ,a(1)
                ,_ret(rr)
        {}


private:
        int _year;
        int _month;
        int _day;
        const int a;
        //别名
        int& _ret;
};

int main()
{
        int b = 10;
        int& r = b;
        Time n(1990, 1, 1,r);
        return 0;
}
//引用也和上方类似，大差不差

注意：

所有的成员，可以在初始化列表初始化，也可以在函数体内初始化

有三类成员必须在初始化列表初始化，1.引用 2.const成员 3.没有默认构造的自定义类型成员

4.初始化列表不管写不写，每个成员变量都会走一遍。

//初始化列表不管写不写，都会走一遍
class Time
{
public:
        
        Time(int x)
        {}


private:
        int _year = 1970;
        int _month =1;
        int _day =1;
        const int a =1;
};

int main()
{
        
        Time n(1);

        return 0;
}

注意：

1.自定义类型会调用它的默认构造(没有默认构造，就会报错)

2.内置类型有缺省值用缺省值，没有缺省值就不一定，看编译器做不做处理。

3.缺省值是给初始化列表用的。

4.先走初始化列表，再走函数体，

5.实践中，尽可能使用初始化列表进行初始化，不方便再使用函数体初始化。

6.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后顺序无关。

class A
{
public:
    A(int a)
        :_a1(a)
        , _a2(_a1)
    {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}
//如上，打印的就是    1 和 随机值

静态成员函数：

静态成员函数特点：

1.在普通函数前 + static

2.static 修饰变量会影响生命周期，修饰函数会影响链接属性

3.修饰成员函数会没有this指针，意味着只能访问静态成员

例如：

 //其中只能访问静态成员，因为没有this指针，所以访问成员对象会报错
 static GetCount()
 {
 
 }

在公有中，我们可以直接访问这个函数，因为它没有this指针

例如：

#include<iostream>
using namespace std;

class A
{
    public: //共有
        A()
        {
            ++_scount;
        }
        A(count A& aa)
        {
            ++_scount;
        }
        ~A()
        {
            --_scount;
        }
        static int GetCount()
        {
            //_aa1 = 1; 
            //上述无法访问，因为没有this指针。
            
            return _scount;
        }

        private://私有
        int _aa1;
        int _aa2;
     public:
        static _scount;
    };
    
    int main()
    {
         A d;
         cout << d:_scount <<endl;
         
        return 0;
    }

友元类：

前提条件：两个类，当类1想访问类2中的对象时，需要在类2中声明友元。

例如如下所示：

//友元

class Time
{
        friend class Month;
public:
        Time()
        {
                _hour = 0;
                _minute = 0;
                _second = 0;
        }

        int Gettime()
        {
                return _hour;
        }


private:
        int _hour;
        int _minute;
        int _second;
};

class Month
{
        
public:
        //无参构造
        
        Month()
        {
                _year = 1970;
                _month = 1;
                _day = 1;

        }
        //带参构造
        Month(int year, int month, int day)
        {
                _year = year;
                _month = month;
                _day = day;
        }
        //拷贝构造
        Month GetMonth(const Month& d)
        {
                _year = d._year;
                _month = d._month;
                _day = d._day;
        }
        //析构函数
        ~Month()
        {
                _year = 0;
                _month = 0;
                _day = 0;
        }

        //友元访问
        void SetTimeOfMonth(int hour, int minute, int second)
        {
                //直接访问时间类内的私有成员变量
                _t._hour = hour;
                _t._minute = minute;
                _t._second = second;
        }

private:
        int _year;
        int _month;
        int _day;
        Time _t;
};

int main()
{
        Month n1;
        Time n2;
        cout <<n2.Gettime() << endl;

        return 0;
}

注意，如果类1没有声明类2的友元，类2无法访问类1中的对象。

内部类：

概念：如果一个类是另一个类的内部，这个内部类就叫内部类。

如下所示：

class Month
{

public:
        //无参构造
        Month()
        {
                _year = 1970;
                _month = 1;
                _day = 1;

        }
        //带参构造
        Month(int year, int month, int day)
        {
                _year = year;
                _month = month;
                _day = day;
        }
        //拷贝构造
        Month GetMonth(const Month& d)
        {
                _year = d._year;
                _month = d._month;
                _day = d._day;
        }
        //析构函数
        ~Month()
        {
                _year = 0;
                _month = 0;
                _day = 0;
        }

        //友元访问
        void SetTimeOfMonth(int hour, int minute, int second)
        {
                //直接访问时间类内的私有成员变量
                _t._hour = hour;
                _t._minute = minute;
                _t._second = second;
        }

        //内部类 ， 内部类是外部类的友元
        class Time
        {
                friend class Month;
        public:
                Time()
                {
                        _hour = 0;
                        _minute = 0;
                        _second = 0;
                }

                int Gettime()
                {
                        return _hour;
                }


        private:
                int _hour;
                int _minute;
                int _second;
        };

private:
        int _year;
        int _month;
        int _day;
        Time _t;
};

int main()
{
        
        return 0;
}

注意：

1.两个类是独立的两个类，如果不想被外部使用，可以定义为私有，外部则无法访问。

如下所示：

class Month
{

public:
        //无参构造
        Month()
        {
                _year = 1970;
                _month = 1;
                _day = 1;

        }
        //带参构造
        Month(int year, int month, int day)
        {
                _year = year;
                _month = month;
                _day = day;
        }
        //拷贝构造
        Month GetMonth(const Month& d)
        {
                _year = d._year;
                _month = d._month;
                _day = d._day;
        }
        //析构函数
        ~Month()
        {
                _year = 0;
                _month = 0;
                _day = 0;
        }

        //友元访问
        void SetTimeOfMonth(int hour, int minute, int second)
        {
                //直接访问时间类内的私有成员变量
                _t._hour = hour;
                _t._minute = minute;
                _t._second = second;
        }
        
 //定义为私有，则外部无法直接访问。
private:
        //内部类 ， 内部类是外部类的友元
        class Time
        {
                friend class Month;
        public:
                Time()
                {
                        _hour = 0;
                        _minute = 0;
                        _second = 0;
                }

                int Gettime()
                {
                        return _hour;
                }


        private:
                int _hour;
                int _minute;
                int _second;
        };
        int _year;
        int _month;
        int _day;
        Time _t;
};

int main()
{
        
        return 0;
}

2.内部类天生就是外部那个类的友元，内部类可以访问外部类，外部类无法访问内部类。（套娃）或叫嵌套类

3.内部类是一个独立的类，放到类里面仅仅收到类域限制。

---------------------------------------------------------------------------------------------------------------------------------

感谢大家观看，点赞加关注，后续更新更多学习内容。