一.构造函数（进阶）
1.构造函数的赋值
虽然下面构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体 内可以多次赋值。
class Date { public: Date(int year, int month, int day) { _year = year; _month = month; _day = day; _a=10;//代码会报错 //构造方法体内部：并不是对成员变量进行初始化，而是赋值 //初始化只能初始化一次，而赋值可以赋值多次 } private: int _year; int _month; int _day; const int _a; };上述代码中我们通过给_a=10给_a赋值但是代码报错。
问题：类中成员变量应该如何进行初始化？因此引出了下面的初始化列表
2.初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括 号中的初始值或表达式。
class Date { public: Date(int year, int month, int day) : _year(year) , _month(month) , _day(day) //,_day(1) //每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次) //类中包含以下成员，必须放在初始化列表位置进行初始化： //1.引用成员变量 //2.const成员变量 //3.自定义类型成员(且该类没有默认构造函数时) ._a(10) ,rday(day) {} private: int _year; int _month; int _day; Time _t; //自定义类型成员 const int _a; int& _rday; };
（3）自定义类型成员
看似代码中没有把TIme类的自定义变量放到初始化列表中进行初始化，但是编译器会进行这一步操作 .
class Time { public: Time() {} private: int _hour; int _minute; int _second; } class Date { public: Date(int year, int month, int day) : _year(year) , _month(month) , _day(day) {} private: int _year; int _month; int _day; Time _t; //自定义类型成员 };
改动后的代码:为什么运行会报错
class Time { public: Time(int hour,int minute,int second) :_hour(hour) ,_minute(minute) ,_second(second) { cout<<"Time()"<<endl; } 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) { cout<<"Date(int,int,int)"<<endl; } void Print()const { cout<<_year<<"//"<<_month<<"_month"<<"/"<<_day<<endl; } private: int _year; int _month; int _day; Time _t; //自定义类型成员 };
解决方式：
1.用户可以将Time类的构造方法给成全缺省的或者给TIme定义无参的构造方法（不推荐）
2.将_t的成员放在Date构造方法初始化列表的位置显示初始化。
3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使 用初始化列表初始化
1.初始化列表可以不写，不写不代表编译器不执行
2.如果不写，对于内置类型的成员变量编译器用随机值初始化
对于自定义类型的成员变量，编译器调用无参或者全缺省的构造方法进行初始化
如果类没有无参或者全缺省的构造方法，则报错。
4 .成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
3.explicit关键字
因此；一般情况下都会禁止掉单参构造方法类型转换的作用
explicit修饰构造方法，表明禁止单参构造方法类型转换的作用。
class Date
{
public:
// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
explicit Date(int year)
:_year(year)
{}
/*
// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转
换作用
// 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;
};
void Test()
{
Date d1(2022);
// 用一个整形变量给日期类型对象赋值
// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
d1 = 2023;
// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}二.static成员
需求：一个类创建了多少个对象
需要一个计数来记录该类创建了多少个对象---->计数肯定是整形
//结论：可以使用全局变量来进行计数
//但是谁都会改变_count的值
int _count=0; //来记录对象个数
class Date
{
public:
Date(int year,int month,int day)
:_year(year)
,_month(month)
,_day(day)
,_count(0)
{
++_count
}
Date(const Date& d)
:_year(d._year)
,_month(d._month)
,_day(d._day)
,_count(++d._count)
{}
~Date()
{
_count--;
}
private:
//普通成员变量
int _year;
int _month;
int _day;
};
void TestObjCount()
{
Date d3(2022,11,19);
Date d4(d3);
}
void TestDate()
{
Date d1(2022,11,19);
Date d2(d1);
if(true)
{
Date d3(d2);
}
TestObjCount();
}
int main()
{
TestDate();
return 0;
}因此引出了Static成员
1.概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的 成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化
如果类中有多个对象可以共享的成员变量，可以完美的解决上述问题
class Date
{
public:
Date(int year,int month,int day)
:_year(year)
,_month(month)
,_day(day)
,_count(0)
{
++_count
}
Date(const Date& d)
:_year(d._year)
,_month(d._month)
,_day(d._day)
,_count(++d._count)
{}
~Date()
{
_count--;
}
private:
//普通成员变量
int _year;
int _month;
int _day;
public:
//静态成员变量
//静态成员变量在类中只是声明，必须要拿到类外进行定义
static int _count;
};
//类中静态成员变量在类外定义时:
//1.必须在成员变量前加类名
//2.在类外定义时不需要再添加static关键字
int Date::_count = 0;
void TestObjCount()
{
Date d3(2022,11,19);
Date d4(d3);
}
void TestDate()
{
Date d1(2022,11,19);
Date d2(d1);
if(true)
{
Date d3(d2);
}
TestObjCount();
}
int main()
{
TestDate();
return 0;
}
class Date
{
public:
Date(int year,int month,int day)
:_year(year)
,_month(month)
,_day(day)
,_count(0)
{
++_count
}
Date(const Date& d)
:_year(d._year)
,_month(d._month)
,_day(d._day)
,_count(++d._count)
{}
~Date()
{
_count--;
}
static int GetCount()
{
return _count;
}
private:
//普通成员变量
int _year;
int _month;
int _day;
private:
static int _count=0;
};
int Date::_count=0;
int main()
{
cout<<Date::GetCount()<<endl;
Date d(2022,11,19);
cout<<d.GetCount()<<endl;
//这种方式虽然可以，但是打印的结果不准确，多了一个对象
//能否不创建对象，也可以直接调用GetCount的方法呢？
//可以的，只需要将GetCount方法使用static修饰
d.func();
Date::GetCount();
return 0;
} 
2.特性
1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制
三.友元
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多 用。 友元分为：友元函数和友元类
1.友元函数
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
void PrintDate(const Date& d)
{
//私有的成员变量不能直接在类外被访问
// cout<<d._year<<"/"<<d._month<<"/"<<d._day<<endl;
}
int main()
{
return 0;
}因此需要引出友元函数：
class Date { public: Date(int year, int month, int day) : _year(year) , _month(month) , _day(day) {} //PrintDate现在就是Date类的友元函数 //可以在PrintDate方法中访问Date类中的私有的成员函数 friend void PrintDate(const Date& d); private: int _year; int _month; int _day; }; void PrintDate(const Date& d) { //私有的成员变量不能直接在类外被访问 // cout<<d._year<<"/"<<d._month<<"/"<<d._day<<endl; //如果一定要访问： //1.可以在类中提供public的公有的方法 //2.友元函数 cout<<d._year<<"/"<<d._month<<"/"<<d._day<<endl; } int main() { return 0; }友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声 明，声明时需要加friend关键字。
友元函数的注意事项：
1.友元函数可访问类的私有和保护成员，但不是类的成员函数（表示友元函数没有this指针）
2.友元函数不能用const修饰
3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4.一个函数可以是多个类的友元函数
例如：
class Time
{
public:
Date(int hour, int minute, int second)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
friend void TestFriend();
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
friend void TestFriend();
private:
int _year;
int _month;
int _day;
};
void TestFriend()
{
Date d(2022,5,5);
d._day+=1;
Time t(13,4,5);
t._second+=1;
}
5.友元函数的调用与普通函数的调用原理相同
class Date
{
public:
Date(int year, int month,int day)
:_year(year)
,_month(month)
,_day(day)
{}
friend ostream& operator<<(ostream& out,const Date& d);
friend istream& operator>>(istream& in ,Date& d)
private:
int _year;
int _month;
int _day;
}
//流插入运算符<<重载，规定：
//第一个参数必须是ostream&，因此该运算符不能重载成类的成员函数，不符合调用常规
//必须要有返回值类型，必须是ostream&，目的是为了支持连续输出
//在输出时，最好不要加格式控制，比如换行
//一般情况下都从在成类的友元函数
//只能将其重载成全局函数
ostream& operator(ostream& out,const Date& d)
{
out<<d._year<<"/"<<d._month<<"/"<<d._day;
return out;
}
istream& operator>>(istream& in ,Date& d)
{
in >>d._year>>d._month>>d._day;
}
int main()
{
int a = 10;
int b = 20;
cout<<a<<" "<<b<<endl;
Date d1(2022,11,19);
Date d2(d1);
cout<<d1<<" "<<d2<<endl;
cin>>d1;
cout<<d1<<endl;
return 0;
}2.友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
举例：
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成
员变量
public:
Time(int hour, int minute , int second )
: _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.友元关系不能传递 如果B是A的友元，C是B的友元，则不能说明C时A的友元。
3.友元关系不能继承
举例
//友元类不具有传递性
class A
{
friend class B; //声明B是A的友元类
public:
A(int a=0)
:_a(a)
{}
private:
int _a;
};
class B
{
friend class C; //声明C是B的友元类
public:
B(int b=0)
:_b(b)
{}
void func()
{
A aa;
aa._a=10;
}
private:
int _b;
};
class C
{
public:
C(int c=0)
:_c(c)
{}
void func()
{
B bb;
bb._b=100;
// A aa;
//aa._a=10; //友元关系不具有交换性
}
private:
int _c;
};四.内部类
概念：
如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外 部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
例子：
class List
{
//ListNode 定义在List内部，将ListNode成为内部类
class ListNode
{
public:
ListNode(int data = 0)
:_next(nullptr)
, _data(data)
{}
ListNode* _next;
int _data;
};
public:
List()
:_head(nullptr)
{}
private:
ListNode* _head;
};注意：
内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中 的所有成员。但是外部类不是内部类的友元。
class A
{
public:
A(int a = 10)
:_a(a)
{}
//内部类
class B
{
public:
B(int b = 0)
:_b(b)
{}
//内部类就是外部的友元类
void func()
{
A aa;
aa._a = 10;
cout << _c << endl;
}
private:
int _b;
};
private:
int _a;
static int _c;
};
int A::_c = 0;
int main()
{
return 0;
}五.类和对象的理解
现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的 实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以 认识。比如想要让计算机认识洗衣机，就需要：
1. 用户先要对现实中洗衣机实体进行抽象---即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有 那些功能，即对洗衣机进行抽象认知的一个过程
2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计 算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣 机用类来进行描述，并输入到计算机中
3. 经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行 描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。
在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性， 那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。
202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
