初识C++ - 类与对象(下篇·下)

目录

再谈构造函数

隐式类型的转换

explicit关键字

单参数

多参数

static静态

一道关于static的题目

友元

友元函数

友元类

内部类

匿名对象

拷贝对象时的一些编译器优化

结束语

---

再谈构造函数

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量

的初始化， 构造函数体中的语句只能将其称为赋初值 ，而不能称作初始化。因为 初始化只能初始

化一次，而构造函数体内可以多次赋值 。

1.2 初始化列表

初始化列表：以一个 冒号开始 ，接着是一个以 逗号分隔的数据成员列表 ，每个 " 成员变量 " 后面跟

一个 放在括号中的初始值或表达式。

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

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

 使用

【注意】

1. 每个成员变量在初始化列表中只能出现一次( 初始化只能初始化一次 )

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

        ①引用成员变量

        ②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 
};

3. 尽量使用初始化列表初始化，因为 不管你是否使用初始化列表(即使没有也会走一遍) ，对于自定义类型成员变量，一定会先使用初始化列表初始化。

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

一道题目

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 ();

}

/*

A . 输出 1   1

B . 程序崩溃

C . 编译不通过

D . 输出 1   随机值

*/

隐式类型的转换

explicit关键字

        构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。用 explicit 修饰构造函数，将会禁止构造函数的隐式转换 。

单参数

//隐式类型的转换
class Date
{
public:
	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
	// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译

	Date(int year)    //当在此语句前添加explicit就不会进行隐式类型的转换了
		:_year(year)
	{}


	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022);
	//隐式类型的转换
	Date d2 = 2022;	//先构造，再拷贝构造，但是现在的编译器可以直接构造

	Date d3(d1);
	Date d4 = d1;

	const Date& d5 = 2022;	//引用

	return 0;
}

检测优化的方式 

//统计A对象创建了多少个，这里测试的比较少，还有传值传参、传值返回之类的都会调用构造
int N = 0;
class A
{
public:
	A(int a = 0)	//构造
		:_a(a)
	{	
		N++;
	}

	A(const A& aa)	//拷贝构造 -- 拷贝构造也算构造
		:_a(aa._a)
	{
		N++;
	}
private:
	int _a;
};


int main()
{
	A aa1(1);
	A aa2 = 1;	//显然这里是被优化之后的结果,否则会显示4个
	A aa3 = aa1;

	cout << N << endl;

	return 0;
}

用途

多参数

//隐式类型的转化
class Date
{
public:


// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
// explicit修饰构造函数，禁止类型转换
Date(int year, int month = 1, int day = 1)	//缺省一个，或者全缺省也可以发生隐式类型的转换
	: _year(year)
	, _month(month)
	, _day(day)
	{}

	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

//注意是C++11后面支持的多参数，单参数的隐式类型转换在C++98就已经支持了
int main()
{
	//隐式类型的转换
	Date d1 = (2022,12,22);	//先构造，再拷贝构造，但是现在的编译器可以直接构造
	//等价于下面的写法，但是本质上是不同的，上面是优化后的结果
	Date d2(2022, 12, 22);

	const Date& d3 = { 2022 ,12 ,22};	//引用

	return 0;
}

static静态

优化下检测，引入静态成员函数与静态成员变量 

//static -- 静态成员变量与静态成员函数
//显然我们通常并不会去使用全局变量，容易被误改
//将它约束到类中显然是一种好方法
class A
{
public:
	A(int a = 0)	//构造
		:_a(a)
	{
		N++;
	}

	A(const A& aa)	//拷贝构造 -- 拷贝构造也算构造
		:_a(aa._a)
	{
		N++;
	}

	static int GetN()//为了让外部得到内部的静态数据
                     //可以利用静态成员函数来实现，通常这俩是一起的
	{                //当然这里是不能访问非静态的成员，静态的只能访问静态的
		return N;
	}

private:
	int _a;

	static int N;	//这是声明，所以不能定义初始化，也不能通过初始化列表去初始化
					//注意这个N并不在栈帧中，而是在静态区中
					//我们也一般设置成私有的，而不是共有的
};
int A::N = 0;	//定义初始化,只能在类外部去初始化，注意要指定类域


int main()
{
	A aa1(1);
	A aa2 = 1;	

	cout << aa1.GetN() << endl;

	cout << A::GetN() << endl;	//有了静态成员函数也可以直接调用，不需要重新定义类对象出来

	A* ptr = nullptr;			//这种也是可以的，不过我们一般不这样做
	cout << ptr->GetN() << endl;

	return 0;
}

一道关于static的题目

JZ64 求1+2+3+...+n -- 链接

描述
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

数据范围： 0 < n \le 2000

示例1
输入：
5

返回值：
15

示例2
输入：
1

返回值：
1

进阶： 空间复杂度 O(1) ，时间复杂度 O(n)

解答

class sum{
public:
    static int GetRet() //让外部得到数据
    {
        return _ret;
    }

    sum()
    {
        _ret += _i;
        _i++;
    }
private:
    static int _i;  //静态的，让其共享一份
    static int _ret;
};
int sum::_i = 1;
int sum::_ret = 0;


class Solution {
public:
    int Sum_Solution(int n) {
        sum a[n];
        return sum::GetRet();
    }
};

//要求禁止常规创建对象的解决方法

class A{
public:
    static A GetObj(int a = 0)  
    {
        A aa1(a);
        return aa1;
    }

private:        //放到私有就无法常规创建对象了
    A(int a = 0)
        :_a(a)
    {      
    }
private:
    int _a;
};


int main()
{
    //static A aa1;       //拷贝构造
    //A* ptr = new aa3;   //new 在堆上创建
    //A aa2;              //最常见的构造       这三种都不可以创建了

    A aa = A::GetObj(10);   //静态成员函数没有this指针

    return 0;
}

友元

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

        友元分为： 友元函数和友元类

友元函数

问题：现在尝试去重载 operator<< ，然后发现没办法将 operator<< 重载成成员函数。 因为 cout 的 输出流对象和隐含的 this 指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作数了。但是实际使用中cout 需要是第一个形参对象，才能正常使用。所以要将 operator<< 重载成 全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>> 同理。

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

class Date
{
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _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;
}

说明 :

        1、友元函数可访问类的私有和保护成员，但 不是类的成员函数

        2、友元函数不能用 const 修饰

        3、友元函数可以在类定义的任何地方声明， 不受类访问限定符限制

        4、一个函数可以是多个类的友元函数

        5、友元函数的调用与普通函数的调用原理相同

友元类

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

①友元关系是单向的，不具有交换性。 A是B的友元，但是反过来B却不是A的友 元

比如上述 Time 类和 Date 类，在 Time 类中声明 Date 类为其友元类，那么可以在 Date 类中直接

访问 Time 类的私有成员变量，但想在 Time 类中访问 Date 类中私有的成员变量则不行。

②友元关系不能传递

如果C 是 B 的友元， B 是 A 的友元，则不能说明 C 时 A 的友元。

③ 友元关系不能继承，在继承再做介绍。

内部类

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

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

特性：

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

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

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

优化上面所做的题目

class Solution {
  public:
    class sum {     //内部类
      public:
        sum() {
            _ret += _i;
            _i++;
        }

    };

    int Sum_Solution(int n) {
        sum a[n];
        return _ret;
    }
  private:
    static int _i;  //静态的，让其共享一份
    static int _ret;
};
int Solution::_i = 1;
int Solution::_ret = 0;

这样看起来要简洁许多了

注意事项：

        关于友元与内部类其实C++并不太喜欢用，Java用的比较多，这种行为会破环类的封装

 

匿名对象

//匿名对象
class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A(int a)" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
};

class Solution {
public:
    int Sum_Solution(int n) {
        //...
        return n;
    }
};

A F()
{
    //A aa1(10);
    //return aa1;
    return A(10);   //有了匿名对象上面两句就直接可以简化成一句了
}
int main()
{
    A aa1;
    // 不能像下面这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
    //A aa1();
     
    // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
    // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数

    A();
    A aa2(2);

    // 匿名对象在这样场景下就很好用，只调用类里面的一个函数，当然还有一些其他使用场景
    Solution().Sum_Solution(10);

    return 0;
}

拷贝对象时的一些编译器优化

        在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

 

//拷贝对象时的一些编译器优化

class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A(int a)" << endl;
    }

    A(const A& aa)
        :_a(aa._a)
    {
        cout << "A(const A& aa)" << endl;
    }

    A& operator=(const A& aa)
    {
        cout << "A& operator=(const A& aa)" << endl;
        if (this != &aa)
        {
            _a = aa._a;
        }
        return *this;
    }

    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
};


void f1(A aa)
{
}
A f2()
{
    A aa;
    return aa;
}

A f3()
{
    //A aa(10);
    //return aa;

    return A(10);
}
int main()
{   
    //优化场景1
    //A aa1 = 1;  //A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)


    //优化场景2
    //A aa1(10);
    //f1(aa1);

    //f1(A(10));  // 构造 + 拷贝构造 -> 优化 构造
    //f1(1);  //有隐式类型转换 构造 + 拷贝构造 -> 优化 构造


    //优化场景3
    //f2();
    //A ret = f2();   //构造+拷贝构造+拷贝构造 -> 优化 构造

    //不可取
    //A ret;
    //ret = f2();


    //优化场景4
    A ret = f3();

 
    return 0;
}

 

 

结束语

钟鼎山林都是梦，人间荣辱休惊，只消闲处过平生。
                                                                -- 《临江仙·再用前韵，送祐之弟归浮梁》