文章目录
一、再谈构造函数
1.1 构造函数体赋值
- 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。
- 构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
#include <iostream>
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2000, 9, 17);//此时就不会报错
Date d2;//会报错
return 0;
}
只要我们用不到默认构造函数，就不会报错【但是，大部分情况下是需要默认构造函数的】
1.2 初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
{
}
//全部初始化列表
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
,_month(month)
{
_day = day;
}
//一部分初始化列表，一部分函数体内初始化
private:
//定义时可以不初始化，后面可以再次进行赋值
int _year;
int _month;
int _day;
//定义的时候必须初始化,
const int _n;
int& ref;
对象定义调用构造函数，进行整体定义。
- 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
- 类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量
- const成员变量
- 自定义类型成员(该类没有默认构造函数)
const int _n;//常量
int& ref;//引用
A _aa;
- 尽量都在初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
- 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。
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.3 explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。
Date d1(2000);//构造
Date d2 = d1;//拷贝构造
//隐式类型的转换
Date d3 = 2013;//构造+拷贝构造=>优化，合二为一：直接构造
- 用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。单参构造函数，没有使用explicit修饰，具有类型转换作用,explicit修饰构造函数，禁止类型转换
explicit Date(int year)
:_year(year)
{}
以下代码可以：
const Date& d5 = 2000;//临时变量具有常性
- 如果有多个参数，但是创建对象时后面的参数可以不传递，没有使用explicit修饰，具有类型转换作用，explicit修饰构造函数，禁止类型转换
二、static成员
2.1 概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。
实现一个类，计算程序中创建了多少个类对象？【构造函数，拷贝构造函数】
//当静态成员变量是共有的
class A
{
public:
A()
{
++_count1;
}
A(const A& aa)
{
++_count2;
}
//类里面声明
static int _count1;
static int _count2;
};
//类外面初始化
int A::_count1 = 0;
int A::_count2 = 0;
A Func(A a)
{
A copy(a);
return copy;
}
int main()
{
A a1;
A a2 = Func(a1);
//静态成员变量属于类，属于类的所有对象
//静态成员为所有类对象所共享，不属于某个具体的实例
//类静态成员即可用 **类名::静态成员**或者**对象.静态成员**来访问
cout << A::_count1 << endl;
cout << A::_count2 << endl;
cout << a1._count1 << endl;
cout << a1._count2 << endl;
return 0;
}
//当静态成员变量是私有的
class A
{
public:
A()
{
++_count1;
}
A(const A& aa)
{
++_count2;
}
//静态成员函数没有隐藏的this指针，不能访问任何非静态成员
static int GetCount1()
{
return _count1;
}
static int GetCount2()
{
return _count2;
}
private:
//类里面声明
static int _count1;
static int _count2;
};
//类外面定义
int A::_count1 = 0;
int A::_count2 = 0;
A Func(A a)
{
A copy(a);
return copy;
}
int main()
{
A a1;
A a2 = Func(a1);
cout << A::GetCount1() << endl;
cout << A::GetCount2() << endl;
cout << a1.GetCount1() << endl;
cout << a1.GetCount2() << endl;
//私有的，在外面就不可以访问
/*cout << A::_count1 << endl;
cout << A::_count2 << endl;
cout << a1._count1 << endl;
cout << a1._count2 << endl;*/
return 0;
}
2.2 特性
- 静态成员为所有类对象所共享，不属于某个具体的实例，它是放在静态区的
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名::静态成员或者对象.静态成员来访问【静态成员：静态成员变量、静态成员函数】
- 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 静态成员和类的普通成员一样，也有public、protected、private 3种访问级别，也可以具有返回值
- 静态成员函数可以调用非静态成员函数吗？ 不可以，因为没有this指针。
- 非静态成员函数可以调用类的静态成员函数吗？可以
三、C++11成员初始化
C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。【初始化列表用缺省值】
【静态的不能在初始化列表初始化，是在类外面初始化】
四、友元
友元：友元函数、友元类
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度【低耦合比较好】（也就是关系），破坏了封装，所以友元不宜多用
4.1 友元函数
问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。
class Date
{
public:
friend std::ostream& operator<<(std::ostream& out, const Date& d);
private:
int _year;
int _month;
int _day;
};
std::ostream& operator<<(std:: ostream& out, const Date& d)
{
out << d._year << "-" << d._month << "-" << d._day << endl;
return out;
}
4.2 友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
- 友元关系是单向的，不具有交换性。
比如A类和B类，在A类中声明B类为其友元类，那么可以在A类中直接访问B
类的私有成员变量，但想在B类中访问A类中私有的成员变量则不行。 - 友元关系不能传递,如果B是A的友元，C是B的友元，则不能说明C时A的友元。【A是B的友元，A就可以访问B的私有】
class Time;//类外 类的前置声明，编译器只会向上找，所以有时候需要前置声明
friend class Date;//友元类可以写到类内任何位置，一般定义到类内的第一行
五、内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
：。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是****。
：
- 内部类可以定义在外部类的public、protected、private都是可以的。【会受访问限定符的限制】
- ，不需要外部类的对象/类名。【外部类其他的私有成员需要对象来访问】
- sizeof(外部类)=外部类，和内部类没有任何关系。【sizeof（类）去掉内部类，去掉静态变量】
六、练习题
- 求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）牛客【知识点：静态】
代码展示：
class Sum
{
public:
Sum()
{
_ret += _i;
++_i;
}
static int GetSum()
{
return _ret;
}
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::GetSum();
}
};
- 计算日期到天数的转换 牛客
代码展示：
#include <iostream>
using namespace std;
int main()
{
int daysArray[13] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
int year;
int month;
int day;
cin >> year >> month >> day;
if (month > 2 && (year % 4 == 0 && year % 100 != 0 || year % 400 == 0))
{
cout << daysArray[month - 1] + 1 + day << endl;
}
else
{
cout << daysArray[month - 1] + day << endl;
}
return 0;
}
- C++是基于面向对象的程序，面向对象有三大特性即：封装、继承、多态。
- 类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象
总结
以上就是今天要讲的内容，本文介绍了类和对象（下），本文以及[C++]类和对象（上）、【C++类和对象】类有哪些默认成员函数呢？（上）、【C++类和对象】类有哪些默认成员函数呢？（下）这四篇文章详细的介绍了类和对象的内容。希望给友友们带来帮助！