类与对象-----下篇-CSDN博客

本文链接：https://blog.csdn.net/Lchilde/article/details/98057134

类与对象-----下篇

1：再谈构造函数

1.1构造函数初始化列表：

构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式，例如：

//构造函数初始化列表
Date::Date(int year, int month, int day)
 :_year(year)
 ,_month(month)
 ,_day(day)
{}
//构造函数赋值
Date::Date(int year, int month, int day) {
 _year = year;
 _month = month;
 _day = day;
}

上面的例子中两个构造函数的结果是一样的。上面的构造函数（使用初始化列表的构造函数）显式的初始化类的成员；而没使用初始化列表的构造函数是对类的成员赋值，并没有进行显式的初始化。

【注意】

每个成员变量在初始列表中只能出现一次（初始化只能初始化一次）
类中包含以下成员，必须在初始化列表中进行初始化
引用成员变量
const成员变量
类类型成员（该类没有默认构造函数）

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

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

1.2:explicit关键字

构造函数不仅可以构造和初始化对象，对于单个参数的构造函数，还具有类型转换的作用

用explicit修饰的构造函数将会禁止单参构造函数隐式类型转换

class Date {
private:
 int _year;
 int _month;
 int _day;
public:
 explicit Date(int year)
  :_year(year)
 {}
};
int main() {
 Date d(1990);
 system("pause");
 return 0;
}

2：static 成员

2.1 概念

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

class Text {
public:
 static int count;
};
int Text::count = 0;
int main() {
 Text t;
 cout << t.count << endl;
 system("pause");
 return 0;
}

结果为：0

class Text {
public:
 static int count;
};
int Text::count = 0;
int main() {
 Text t1,t2;
 t1.count = 100;
 cout << t2.count << endl;
 system("pause");
 return 0;
}

结果为：100
static不像普通类数据成员一样每一个类对象都有一份，全部类对象是共享一个static成员的，例如A对象修改了static成员为1，那么B对象对应的static成员也为1

好处：用static修饰的成员变量在对象中是不占内存的，因为它不是跟对象一起在堆或栈中生成的，用static修饰的成员在静态存储区生成，所以用static修饰的成员可以节省对象的空间

static成员函数

由于static修饰的成员属于类，不属于对象，因此static类成员函数时没有this指针的，this指针是指向本对象的指针。正因为没有static没有this指针，所以static类成员函数不能访问非static成员，只能访问static修饰的成员。

class Text {
public:
 static int count;
 int num;
 static int fun() {
  return num;
 }
};
int Text::count = 0;
int main() {
 Text t;
 t.count = 100;
 t.fun();//发生错误，fun函数return的是非static类成员，如果return count就正确
 system("pause");
 return 0;
}

2.2 特性

静态成员为所有类对象共享，不属于某一具体的实例
静态成员变量必须在类外定义，定义时不必加static关键字
类静态成员即可用类名：：静态成员或对象静.态成员来访问
静态成员没有隐藏的this指针，不能访问任何非静态成员
静态成员和类的普通成员一样，都具有public，private，protected三种访问级别，也具有返回值

2.3
静态成员函数不可以调用非静态成员函数，非静态成员函数可以调用类静态成员函数

3：友元
3.1：友元函数

概念：友元函数是定义在类外部，但有权访问类的所有私有成员和保护成员，友元函数并不是成员函数，声明是需要加friend关键字

test.h

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

test.cpp

#include"test.h"
Date::Date(int year,int month,int day)
 :_year(year)
 ,_month(month)
 ,_day(day)
{}
ostream& operator<<(ostream& _cout, const Date& d) {
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout;
}
istream& operator>>(istream& _cin, const Date& d) {
 _cin >> d._year >> "-" >> d._month >> "-" >> d._day;
 return _cin;
}
int main() {
 Date d(1990, 1, 1);
 cin >> d;
 cout << d << endl;
 system("pause");
 return 0;
}

【说明】：

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

3.2 友元类

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

test.h

class Date;
class Time {
 friend class Date;
private:
 int _hour;
 int _minute;
 int _second;
public:
 Time(int hour,int minute,int second);
};
class Date {
private:
 int _year;
 int _month;
 int _day;
 Time _t;
public:
 Date(int year,int month,int day);
 void setTimeofDate(int hour, int minute, int second);
};

test.cpp

#include"test.h"
Time::Time(int hour,int minute,int second)
 :_hour(hour)
 ,_minute(minute)
 ,_second(second)
{}
Date::Date(int year,int month,int day)
 :_year(year)
 ,_month(month)
 ,_day(day)
{}
void Date::setTimeofDate(int hour, int minute, int second) {
 _t._hour = hour;
 _t._minute = minute;
 _t._second = second;
}
int main() {
 Time t(16,16,16);
 Date d(1990, 1, 1);
 d.setTimeofDate(16, 2, 2);
}

4:内部类

4.1 概念：

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

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

4.2 特性：

特性：

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系。

test.h

class A {
private:
 int k=1;
 static int h;
public:
 class B {
 public:
  void print(const A& a);
 };
};
int A::h = 1;

test.cpp

#include"test.h"
void A::B::print(const A& a) {
 cout << a.k << endl;
 cout << h << endl;
}
int main() {
 A a;
 A::B b;
 b.print(a);
 system("pause");
 return 0;
}