C++-类和对象-3

2024年7月 · 预计阅读时间： 3 分钟

构造函数的初始化列表
对象赋值构造与explicit关键词
static成员
c++11类成员初始化新方法
友元
内部类

构造函数的初始化列表#

之前的构造函数只是在创建对象的时候，赋给成员变量初值。

class Date
{ 
public :
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
...
}

想要真正直接初始化可以使用初始化列表：

class Date
{ 
public :
    Date(int year = 1900, int month = 1, int day = 1)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {
    }
...
}

注意：

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
以下成员必须要在初始化列表中进行初始化：
- const成员
- 引用成员
- 没有默认构造函数的自定义类型成员（默认构造函数是指，无参或全缺省参数的构造函数）
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与初始化列表顺序无关

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 随机值

对象赋值构造与explicit关键词#

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用

Date d2 = 2020;

上面这个式子的过程是，先通过tmp(2020)创建一个临时的Date对象，然后使用这个临时对象拷贝构造d2，即：

const Date tmp(2020);
Date d2(tmp);

用explicit修饰构造函数，将会禁止单参构造函数的隐式转换：

class Date
{
explicit Date(int year)
    :_year(year)
    {}
}

static成员#

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；

用static修饰的成员函数，称之为静态成员函数。

静态的成员变量一定要在类外进行初始化。

问：如何实现一个类，计算程序中创建了多少个类的对象？

#include <iostream>
class A
{
public:
    A(){++cnt;}
    A(const A& t){++cnt;}
    static int getAcnt(){return cnt;};
private:
    static int cnt;
};

int A::cnt = 0;

int main(int argc, const char** argv) {
    A a1, a2;
    A a3(a1);

    std::cout << A::getAcnt() << std::endl;

    return 0;
}

静态成员为所有类对象所共享，不属于某个具体的实例
静态成员变量必须在类外定义，定义时不添加static关键字
类静态成员即可用类名::静态成员或者对象.静态成员来访问
静态成员函数没有隐藏的this**指针**，不能访问任何非静态成员
静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

问：静态成员函数可以调用非静态成员函数吗？

不可以，因为没有this指针，无法调用类里面的非静态成员函数。

C++11成员初始化新特性#

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

class Date
{
public:
    Date();
    void PrintDate();
private:
    int _year=2024;
    int _month=7;
    int _date=1;
};

void Date::PrintDate()
{
    cout<<_year<<"-"<<_month<<"-"<<_date<<endl;
}

int main(int argc, const char** argv) {
    Date a;
    Date b(0, 0, 1);

    a.PrintDate();
    b.PrintDate();
    return 0;
}

友元#

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏封装。

友元函数#

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类里面声明friend关键字。

友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰，它没有this指针
友元函数可以在类定义里的任何地方声明，不受类访问限定符的限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用与原理相同

下面的日期类实现了<<操作符，这个操作符无法在类的内部实现，因为左操作符的位置会被this指针占据，就修改了<<的含义

class Date
{
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year, int month, int day)
        : _year(year)
        , _month(month)
        , _day(day)
    {}

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

ostream& operator<<(ostream& _cout, const Date& d)
{
    _cout<<d._year<<"-"<<d._month<<"-"<<d._day;

    return _cout;
}

istream& operator>>(istream& _cin, Date& d)
{
    _cin>>d._year;
    _cin>>d._month;
    _cin>>d._day;

    return _cin;
}

int main()
{
    Date d;
    cin>>d;
    cout<<d<<endl;
    return 0;
}

友元类#

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

友元关系是单向的，不具有交换性。
- 比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递。如果B是A的友元，C是B的友元，则不能说明C是A的友元。

内部类#

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

即内部类就是外部类的友元类。（内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。）

class A
{
private:
    static int k;
    int h;
public:
    class B
    {
    public:
        void foo(const A& a)
        {
        cout << k << endl;//OK
        cout << a.h << endl;//OK
        }
    };
};

int A::k = 1;
int main()
{
    A::B b;
    b.foo(A());

    return 0;
}

近期文章