本文主要是C++基础入门--C++类和对象总结，通过具体的内容展现，希望对大家C++的学习有一定的帮助。

本篇文章将会主要讲解构造函数的初始化列表,static成员,以及内部类,目的是对前几章讲解类时候的一个深入和总结.

再谈构造函数

我们上一节讲解构造函数时候,了解了构造函数的定义和使用,明白编译器会通过调用构造函数给类成员一个初始值,但是注意了~~,这个过程却并不是初始化,而是只能叫做赋初值,因为初始化只能一次,比如下面的一段代码:

class A {

public:

    A(int c = 10) {

        cout << "A(int c)" << endl;

        _c = c;

    }

private:

    int _c;

};

class B {

public:

    B(int a,int b,A& ca) {

        _a = a;

        _b = b;

        _ca = ca;

    }

private:

    int _a;

    int _b;

    A _ca;

};

int main() {

    A a(20);

    B b(1,2,a);

    return 0;

}

大家觉得上面的结果会是什么?没错,会打印两句A(int c),但是博主在这里有个小小问题,就这两句分别在哪一行代码后打印的呢?

答案:

第一次定义A对象后,会调用一次构造函数,也就打印了第一句A(int c).

第二次打印确是在程序B(int a,int b,A& ca)之后,程序_a = a之前,也就是在这两句之间,不信吗?我们下图为例:

当程序执行到_a = a以后,已经打印出了A(int c),那么这是为什么呢? 请看下一小节的初始化列表.

初始化列表

以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式

什么意思呢?如下:

class Date {

public:

    Date(int year, int month, int day) 

        :_year(year),_month(month),_day(day)

    {

    }

    void Print(){

        cout<<"year是"<<_year<<endl;

        cout<<"month是"<<_month<<endl;

        cout<<"day是"<<_day<<endl;

    }

private:

    int _year;

    int _month;

    int _day;

};

int main(){

    Date date(2021,10,23);

    date.Print();

return 0;

}

我们可以清晰地看到,通过构造函数的初始化列表,就已经成功初始化了类数据成员.所以现在大家应该已经明白了,为什么说初始化列表才是真正的初始化数据成员,而通过构造函数的函数体赋值形式叫做初次赋值.因为在函数体内部的赋值性质是可以修改初始化列表的结果,比如把构造函数改成下面这样:

    Date(int year, int month, int day) 

        :_year(year),_month(month),_day(day)

    {

            _year = 2000;

            _month = 1;

            _day = 1;

    }

那么刚才的结果将会是这样:

初始化列表注意点

①每个数据成员只能在初始化列表中出现一次(因为只能初始化一次),还是按照上面的Date类为例,若这样写就错误了:

Date(int year, int month, int day) 

    :_year(year),_month(month),_day(day),_year(2000),_month(10),_day(20)

{

}

②数据初始化顺序只和数据声明顺序有关,与初始化列表无关:

class A

{

public:

A(int a)

:_a1(a)

,_a2(_a1)

{}

void Print() {

cout<<_a1<<" "<<_a2<<endl;

}

private:

int _a2;

int _a1;

};

该类的结果为:

我们能够发现,_a2的值并不是100,因为最开始初始化的数据就是_a2,但是给_a2的值缺是还没有初始化的_a1

③当类中含有以下三种数据成员时候,对他们初始化必须使用初始化列表,分别是:

引用成员变量

const成员变量

自定义类型成员变量(没有默认的构造函数时候)

class A

{

public:

    A(int a)

    :_a(a)

    {}

private:

    int _a;

};

class B

{

public:

    B(int a, int ref)

    :_aobj(a)

    ,_ref(ref)

    ,_n(10)

    {}

private:

    A _aobj; // 没有默认构造函数

    int& _ref; // 引用

    const int _n; // const

};

explicit关键字

他的作用说简单点就是不允许定义对象时候使用=形式初始化,比如:

class Date {

public:

    explicit Date(int n) 

    {

        _n = n;

    }

private:

    int _n;

};

int main()

{

    Date date1(100);  

    Date date2 = 100; //正常情况下,这样也是可以初始化的,但是加了explict就不可以.

    return 0;

}

static成员

概念:主要有两种,一种是修饰数据成员,称为静态成员变量.一种是修饰成员函数,称为静态成员函数.其中静态成员变量必须在类外进行初始化,并且静态成员大小不计算在类内.

其特性为:

静态成员为所有类对象所共享，不属于某个具体的实例

class Date {

  public:

    Date(int b  = 10)

    {

        _a++;

        _b = b;

    }

    static void cntans()

    {

        cout<<_a<<endl;

    }

    private:

static int _a;    

    int _b;

};

int Date::_a = 10;   //静态成员必须在外面初始化.

int main()

{

    Date d1;

    Date d2;

    Date d3;

    d1.cntans();

    d2.cntans();

    d3.cntans();

    return 0;

}

大家猜猜会打印什么呢?答案如下:

可以清晰的看到,三次打印都是13,原因就是因为静态成员由所有类对象共享,并不是属于某个具体对象

类静态成员即可用类名::静态成员或者对象.静态成员来访问

在上面我们已经使用过了对象.静态成员访问格式,现在就介绍一下类名::静态成员.

仍然以上面为例:

int main(){

Date d1;

    Date::cntans();    //类名::静态成员格式

    return 0;

}

静态成员函数没有隐藏的this指针，不能访问任何非静态成员

我们仍然以上面Date类为例,比如下面的修改cntans函数的错误形式:

    static void cntans()

    {

        cout<<_a<<endl;  //_a是静态成员,类内访问没问题.

        cout<<_b<<endl; //但是_b是非静态成员,由于没有this指针,所以访问_b非法.

    }

静态成员和静态函数也有public、protected、private3种访问级别，也可以具有返回值

这个博主就不再赘述,大家自行检查.

友元

友元和静态很相似,具有两种.修饰函数的叫做友元函数,修饰类的叫做友元类.在我们介绍这个之前,先做一个小测验吧,我们利用之前学过的重载运算符,对<<或者>>进行重载,实现的类仍然是我们上面的日期类

友元函数

class Date

{

public:

    Date(int year, int month, int day)

    : _year(year)

    , _month(month)

    , _day(day)

    {}

    ostream& operator<<(ostream& out)

    {

    out<<_year<<"-"<<_month<<"-"<<_day;

    return cout;

    }

private:

    int _year;

    int _month;

    int _day;

};

大家觉得我们这样进行重载,会不会有什么问题呢?我们先调用一下试试吧.

Date date(2021,10,10);

cout << date;

我们进行编译,运行然后就能发现结果报错:

为什么呢?我们之前在讲运算符重载时候强调过,我们在写参数列表时,需要按照运算符的操作数格式进行重载.但是这里呢>我们按照了吗,并没有,因为这里有隐藏的this指针,也就是说操作数弄反位置了.那怎么进行修改呢?目前我们的办法只有一个,那就是放到全局:

ostream& operator<<(ostream& out,Date& date)

{

    out << _year << "-" << _month << "-" << _day;

    return cout;

}

但是像这样又会遇到一个问题,那就是_year等成员是私有的,在外部无法访问.那又怎样进行解决呢?现在就是我们的老大哥—friend友元驾临.

这种情况我们只需要在类Date中的任何位置放一份重载函数声明,并在前面加上friend.

class Date

{

    friend ostream& operator<<(ostream& out,Date& date);  //一般习惯性的是加在这里

public:

    Date(int year, int month, int day)

    : _year(year)

    , _month(month)

    , _day(day)

    {}    

private:

    int _year;

    int _month;

    int _day;

};

注意:友元函数,只需要在函数的声明前加上friend就行,并且友元不属于任何类,只是为了突破类的作用域限制,以达到访问类的私有或保护成员.

并且友元函数不可以用const进行修饰,不受任何的类作用域符限制,而同一个友元函数还可以是多个类的友元.

友元类

友元类和友元函数相似,当一个类A是类B的友元类后,类A便可以访问B的任何成员和函数.使用方法和友元函数一模一样,不再介绍.

内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元.

特性：

内部类可以定义在外部类的public、protected、private都是可以的。

注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

sizeof(外部类)=外部类，和内部类没有任何关系

class A

{

private:

    static int k;

    int h;

public:

    class B

    {

    public:

        void foo(const A& a)

        {

            cout << k << endl;//

            cout << a.h << endl;//   //想要访问外部类的其他成员,必须通过外部类的对象参数.

        }

    };

};

int A::k = 1;

int main()

{

    A::B b;        //定义内部类,只能通过作用域限制符.

    b.foo(A());

    return 0;

}

我是小职，记得找我

✅ 解锁高薪工作

✅ 免费获取基础课程·答疑解惑·职业测评