类和对象(下)

发布于:2024-07-11 ⋅ 阅读:(18) ⋅ 点赞:(0)

构造函数(补充)

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

虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象中成员变量的初始化,构造函数体中的语句只能将其称为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值。 

初始化列表
class A
{
public:
	A(int a)
		:_a(a)
	{
		cout << "A" << endl;
	}
private:
	int _a;
};

class Date
{
public:
	// 初始化列表是每个成员变量定义初始化的位置
	// 能用初始化列表就用初始化列表
	Date(int year, int month, int day, int& x)
		:_year(year)
		, _month(month)
		, _day(day)
		, _n(1)
		, _m(x)
		, _aa(0)
		, _p((int*)malloc(sizeof(4)))
		// 初始化列表规定一个变量只能出现一次
	{
		// 赋值修改
		if (_p == nullptr)
		{
			perror("malloc fail");
		}
	}

private:
	// 声明
	int _year = 1;// 缺省值
	int _month;
	int _day;

	int* _p;

	// 必须走初始化
	const int _n;
	int& _m;// 引用必须在定义的时候初始化
	A _aa;
};
int main()
{
	int x = 10;
	// 对象实例化
	Date d1(2024, 7, 6, x);
	return 0;
}

当类中包含以下成员的时候必须通过初始化列表初始化

1.const修饰成员变量

2.引用成员变量

3.自定义类型成员(没有默认构造函数)(当有默认构造函数时,不需要显示写走初始化列表也会调用它的默认构造函数)

除了这三个以外其他均可和函数体混用

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

隐式类型的转换

我们知道不同类型对象之间赋值中间会产生临时对象,也就是先会创建一个临时对象进行构造再拷贝构造,那看下面这个代码

class C
{
public:
	C(int c = 0)
		:_c(c)
	{}
	C(const C& c)
	{
		cout << "C" << endl;
	}
private:
	int _c;
};

int main()
{
	C a(0);
	// 单参数构造函数支持隐式类型的转换
	// 0构造一个临时对象,再拷贝构造 
	C b = 0;
	// C d = 1.1;
	// 部分编译器允许double等其他类型,编译器会将其先强转,再用int构造
	return 0;
}

上面代码中b并没有调用拷贝构造,只进入了构造函数没有进入拷贝构造

原因时编译器优化了,同一个表达式连续步骤的构造,一般会合二为一

class C
{
public:
	C(int c = 0)
		:_c(c)
	{}
	C(const C& c)
	{
		cout << "C" << endl;
	}

int main()
{
	
	// C& d = 0;
	// 上面会报错,因为引用的实际是0的临时对象,而临时对象具有常性
	const C& d = 0;
	return 0;
}

这样意味着我们代码可以像下面这样 

class C
{
public:
	C(int c = 0)
		:_c(c)
	{}
	C(const C& c)
	{
		cout << "C" << endl;
	}
private:
	int _c;
};

class Stack 
{
public:
	void Push(const C& x)
	{}
};

int main()
{
	Stack st;
	// c中得先定义对象再传参
	C cc1(1);
	st.Push(cc1);
	// c++中可以直接隐式类型转换
	st.Push(1);

	return 0;
}

 c++98中支持的是单参数的标准就像上面的代码,而在c++11之后就支持多参数 

class A
{
public:
	A(int a1, int a2)
		:_a1(a1)
		,_a2(a2)
	{}
private:
	int _a1;
	int _a2;
};

int main()
{
	A aa1 = { 1,2 };
	const A& aa2 = { 1,2 };
	return 0;
}

而当我们不想要隐式类型转换的时候我们可以在构造前面加上explicit关键字,这样就会在转换时报错

static成员

对于用static修饰的成员函数,称为静态成员函数,成员变量称为静态成员变量。如果对于一个成员,对其以static修饰,此时这个成员就不再属于对象,而是属于这一整个类的所有对象。因为静态的成员的生命域不在类中,在静态区,所以静态的成员只能在类外初始化。

特性

1.静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区

2.静态成员必须在类外定义,定义时不添加关键字static,类中只是声明

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

4.静态成员函数没有this指针,不能访问非静态成员

5.静态成员也是类的成员受访问限定符限制

静态成员特性与成员函数类似

class A
{
public:
	A()
	{}
	static int n;
};

int A::n = 0;

int main()
{
	A* aa1 = nullptr;
	cout << aa1->n << endl;
	return 0;
}

这里虽然是一个空指针,但它也不在这个指针指向的对象里面, 它是去静态区中查找,指针只是让它突破类域,让它能够去A中寻找

下面看牛客网上一个题目

求1+2+3+...+n_牛客题霸_牛客网

一个利用静态成员的解法就是一个变长数组存n个数,每个都会调用一次构造,在构造里面记录增长,返回总值

class Sum
{
public:
    Sum()
    {
        _sum += _m;
        ++_m;
    }
    static int GetSum()
    {
        return _sum;
    }
private:
    static int _m;
    static int _sum;
};

int Sum::_m = 1;
int Sum::_sum = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum A[n];
        return Sum::GetSum();
    }
};

友元

友元函数

函数重载再补充一个流插入和流提取的重载

class Date
{
public:
	Date(int year = 0, int month = 0, int day= 0)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
	// 因为成员函数第一个参数一定是隐藏的this,所以d1必须放在<<的左侧
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
	istream& operator>>(istream& _cin)
	{
		_cin >> _year;
		_cin >> _month;
		_cin >> _day;
		return _cin;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	// d1.operator>>(cin);
	d1 >> cin;

	// d1.operator<<(cout);
	d1 << cout; 
}

如果函数时双操作数的话,参数和类型必须要匹配,第一个数是左操作数,第二个数是右操作数, 所以重载后的调用就变成了上面这样,和我们的预期完全相反,cout变成控制台流入到日期类中,这就是因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。那么Date就只能是左操作数,所以就不能写成成员函数,把它重载成全局函数。但又会受到访问限定符的限制,类外没办法访问私有和保护成员,此时就需要友元来解决。operator >> 同理 

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

ostream& operator<<(ostream& _cout, const Date& _d)
{
	_cout << _d._year << "-" << _d._month << "-" << _d._day << endl;
	return _cout;
}
istream& operator>>(istream& _cin, Date& _d)
{
	_cin >> _d._year;
	_cin >> _d._month;
	_cin >> _d._day;
	return _cin;
}

int main()
{
	Date d1;
	// d1.operator>>(cin);
	cin >> d1;

	// d1.operator<<(cout);
	cout << d1;
}

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

补充说明

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

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

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

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

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

友元类

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

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

1.友元关系是单向的,不具有交换性,比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。

2.友元关系不具有传递性

3.友元关系不能继承

内部类

如果一个类定义在另一个类内部,这就叫做内部类,内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。但是内部类就是外部类的友元类,内部类可以通过外部类的对象参数来访问外部类中的所有成员。

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

特性

1.内部类可以定义在外部类的任意位置,不受访问限定符限制

2.内部类可以直接访问外部类的static成员,不需要外部类的对象类名

3.sizeof(外部类)大小就是外部类,和内部类没有关系

匿名对象

匿名对象是一个临时对象,它的生命周期就在当前这一行,执行完后会立即销毁

class A
{
public:
	A(int i = 0)
		:_i(i)
	{
		cout << "A(int i)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _i;
};

int main()
{
	A aa1;
	A aa2(10);


	// 匿名对象会在构造完成后,直接析构
	// 它的生命周期就在当前一行
	A();
	A(10);

	return 0;
}