C++类和对象（四）

于 2024-04-23 15:50:06 发布
阅读量618 收藏 10
点赞数 18
分类专栏： C++ 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79351530/article/details/137884493
版权
本文详细讨论了C++中构造函数的使用，包括初始化列表的规则、自定义类型成员的初始化、静态成员的特性、友元的作用以及内部类和匿名对象的概念。通过实例展示了如何正确地初始化类的成员，以及避免常见的编程错误。
摘要由CSDN通过智能技术生成

1.构造函数的补充

1.1初始化列表

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

#include <iostream>
using namespace std;

class Date 
{
public:
	Date(int year,int month,int day) 
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 4, 17);
	d1.Print();
	return 0;
}

【注意】

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

  • 引用成员变量
  • const成员变量
  • 自定义类型成员(且该类没有默认构造函数时)
  • #include <iostream>
using namespace std;
class Stack 
{
public:
	Stack(int capacity)
	{
		int* a = (int*)malloc(sizeof(int));
		if (a == nullptr)
		{
			perror("malloc fail");
			exit(1);
		}
		_a = a;
		_capacity = capacity;
		_top = 0;
	}
	~Stack()
	{
		if (_a)
		{
			free(_a);
			_capacity = 0;
			_top = 0;
		}
	}
private:
	int* _a;
	int _capacity;
	int _top;
};
class MyQueue 
{
public:

private:
	Stack t1;
	Stack t2;
};
int main()
{
	MyQueue q1;

	return 0;
}

    这一段代码会出现如下问题，这一点我们在之前的篇章有详细解释，因为Stack中没有默认构造函数，所以无法正常定义MyQueue对象，现在我们可以通过初试化列表的方式来进行解决；

#include <iostream>
using namespace std;
class Stack 
{
public:
	Stack(int capacity)
	{
		int* a = (int*)malloc(sizeof(int));
		if (a == nullptr)
		{
			perror("malloc fail");
			exit(1);
		}
		_a = a;
		_capacity = capacity;
		_top = 0;
	}
	~Stack()
	{
		if (_a)
		{
			free(_a);
			_capacity = 0;
			_top = 0;
		}
	}
	
private:
	int* _a;
	int _capacity;
	int _top;
};
class MyQueue 
{
public:
	MyQueue(int n)
		:t1(n)
		,t2(n)
        ,n(n)
	{
	}
private:
	Stack t1;
	Stack t2;
    const int n;
};
int main()
{
	MyQueue q1(0);

	return 0;
}

如果不在初试化列表对n进行初始化便会报错。

#include <iostream>
using namespace std;
class Stack 
{
public:
	Stack(int capacity)
	{
		int* a = (int*)malloc(sizeof(int));
		if (a == nullptr)
		{
			perror("malloc fail");
			exit(1);
		}
		_a = a;
		_capacity = capacity;
		_top = 0;
	}
	~Stack()
	{
		if (_a)
		{
			free(_a);
			_capacity = 0;
			_top = 0;
		}
	}
	
private:
	int* _a;
	int _capacity;
	int _top;
};
class MyQueue 
{
public:
	MyQueue(int n,int &p)
		:t1(n)
		,t2(n)
		,n(n)
		,_p(p)
	{
	}
private:
	Stack t1;
	Stack t2;
	const int n;
	int& _p;
};
int main()
{
	int a = 0;
	int& pp=a;
	MyQueue q1(0,pp);
	return 0;
}

完整的初始化列表如上。

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

#include <iostream>
using namespace std;
class Stack 
{
public:
	Stack(int capacity=4)
	{
		int* a = (int*)malloc(sizeof(int));
		if (a == nullptr)
		{
			perror("malloc fail");
			exit(1);
		}
		_a = a;
		_capacity = capacity;
		_top = 0;
	}
	~Stack()
	{
		if (_a)
		{
			free(_a);
			_capacity = 0;
			_top = 0;
		}
	}
	
private:
	int* _a;
	int _capacity;
	int _top;
};
class MyQueue 
{
public:
	MyQueue()
	{
		_size = 0;
	}
private:
	Stack t1;
	Stack t2;
	/*const int n;*/
	/*int& _p;*/
	int _size;
};
int main()
{
	int a = 0;
	int& pp=a;
	MyQueue q1;
	return 0;
}

例如上边这段代码，我们没有对MyQueue这个类写初始化列表但是 编译器会自动生成初始化列表并且对于变量进行定义。通过调试我们可以观察到t1以及t2均调用了stack的默认构造函数进行了初始化。

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
次序无关。如下代码，该类的成员变量在声明时是_a2在前，_a1在后，因此虽然初始化列表中显示对_a1先进行初始化但是实际上还是先对_a2进行初始化此时的_a1是一个随机值所以_a2就被初始化为随机值，最后再对_a1初始化。

#include<iostream>
using namespace std;
class A 
{
public:
	A(int n)
		:_a1(n)
		,_a2(_a1)
	{
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};
int main()
{
	A a(3);
	a.Print();
	return 0;
}

1.2隐式类型转换

1.2.1单参数构造函数隐式类型转换

转换过程中会产生临时变量。

#include <iostream>
using namespace std;
class a 
{
public:
	a(int a)
		:_a(a)
		,_a1(a)
		,_a2(a)
	{}
	a(int a1,int a2)
		:_a(0)
		,_a1(a1)
		,_a2(a2)
	{}
private:
	int _a;
	int _a1;
	int _a2;
};
int main()
{
	a aa1(7);
	a aa2 = 8;
	//这里就是单参数隐式类型转换，编译器自动把1这个整形转换为了a这个类 相当于编译器把1传给了构造函数，
	//构造了一个A类，接着再把构造好的类拷贝给aa2；
    //raa引用的是类型转换中3构造的临时变量（临时变量具有常性因此需要用const来进行修饰）
    const a& aa = 3;
    return 0;
}

1.2.2多参数构造函数隐式类型转换

多参数的构造函数的隐式类型转化道理和单参数相同但是形式上要用{}来对变量进行修饰。

#include <iostream>
using namespace std;
class a
{
public:
	a(int a1, int a2)
		:_a(0)
		, _a1(a1)
		, _a2(a2)
	{}
private:
	int _a;
	int _a1;
	int _a2;
};
int main()
{
	a aaa1(2, 1);
	a aaa2 = { 1,2 };
	return 0;
}

1.2.3explicit关键字

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

#include <iostream>
using namespace std;
class a
{
public:
	explicit a(int a1, int a2)
		:_a(0)
		, _a1(a1)
		, _a2(a2)
	{}
private:
	int _a;
	int _a1;
	int _a2;
};
int main()
{
	a aaa1(2, 1);
	a aaa2 = { 1,2 };
	return 0;
}

2.static成员函数

2.1概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用
static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

2.2特性

  • 1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区，如下面代码因为_a3是静态成员不属于A这个类，所以A的大小是8而不是12。
#include<iostream>
using namespace std;
class A
{
public:
	A()
	:_a1(1)
	,_a2(2)
	{
	}
private:
	int _a1 ;
	int _a2 ;
	static int _a3 ;
};
int main()
{
	cout << sizeof(A) << endl;
	return 0;
}

  • 2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。
#include<iostream>
using namespace std;
class A
{
public:
	A()
	:_a1(1)
	,_a2(2)
	,_a3(2)
	{
	}
private:
	int _a1 ;
	int _a2 ;
	static int _a3 ;
};
int main()
{
	cout << sizeof(A) << endl;
	return 0;
}

  • 3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问，只有当类静态成员不是私有的时候才可以。

当类静态成员是私有时就会报错。

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

下边代码不能编译成功，需要给Print函数传一个A的对象。

#include<iostream>
using namespace std;
class A 
{
public:
	static void Print()
	{
		cout << k << " " << h;
		
	}
private:
	static int k;
	int h;
};
int A::k = 1;
int main()
{
	A a1;
	a1.Print();
	return 0;
}

#include<iostream>
using namespace std;
class A 
{
public:
	static void Print(const A &a)
	{
		cout << k << " " << a.h;
		
	}
private:
	static int k;
	int h;
};
int A::k = 1;
int main()
{
	A a1;
	a1.Print(A());
	return 0;
}
  • 5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。
#include<iostream>
using namespace std;
class A 
{
private:
	static void Print(const A &a)
	{
		cout << k << " " << a.h;
		
	}
private:
	static int k;
	int h;
};
int A::k = 1;
int main()
{
	A a1;
	a1.Print(A());
	return 0;
}

上边的Print函数就是属于A中的私有成员函数，因此在main函数中不能直接进行调用。

3.友元

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

3.1有元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在
类的内部声明，声明时需要加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;
}

说明：

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

3.2友元类

class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
//中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
  • 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。友元关系是单向的，不具有交换性。
  • 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
  • 友元关系不能传递，如果C是B的友元， B是A的友元，则不能说明C时A的友元。

4.内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越
的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访
问外部类中的所有成员。但是外部类不是内部类的友元。
特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。
 

class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
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;
}

5.匿名对象

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;
}
};
int main()
{
A aa1;
// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
//A aa1();
// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
A();
A aa2(2);
// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
Solution().Sum_Solution(10);
return 0;
}；

igmaple
关注
  • 18
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值