类和对象（下）

文章目录

• 前言
• 一. 再谈构造函数  
• 二. Static 成员
• 三. 友元
• 四. 内部类
• 五. 匿名对象
• 六. 拷贝对象时的一些编译器优化
• 七. 再次理解封装
• 总结

---

前言

类是一种模板或蓝图，用于创建对象。它定义了对象的属性和方法。对象是类的实例化，它具有类定义的属性和方法。

类可以包含属性和方法。属性是类的特征或数据。方法是类的行为或功能。例如，一个人的类可以有属性如姓名、年龄和性别，方法如说话和走路。

创建对象时，可以使用类来实例化对象。对象可以访问类中定义的属性和方法。例如，可以创建一个人的对象，访问其姓名属性和说话方法。

类和对象的关系是一种面向对象编程的基本概念。它允许开发人员根据现实世界中的概念和关系来设计和实现代码。通过使用类和对象，可以更好地组织和管理代码，并提供更好的代码复用性和可维护性。

---

一. 初始化列表

1.构造函数赋值

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

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

2.初始化列表

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

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

【注意】

1. 每个成员变量在初始化列表中 只能出现一次 ( 初始化只能初始化一次 )

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const 成员变量

自定义类型成员 ( 且该类没有默认构造函数时 )

class A
{
public:
 A(int a)
 :_a(a)
 {}
private:
 int _a;
};
class B
{
public:
 B(int a, int ref)
 :_aobj(a)
 ,_ref(ref)
 ,_n(10)
 {}
private:
 A _aobj;  // 没有默认构造函数
 int& _ref;  // 引用
 const int _n; // const 
};

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

class Time
{
public:
 Time(int hour = 0)
 :_hour(hour)
 {
     cout << "Time()" << endl;
 }
private:
    int _hour;
};
class Date
{
public:
     Date(int day)
     {}
private:
     int _day;
     Time _t;
};
int main()
{
    Date d(1);
}

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

次序无关

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

二. Static成员

1.概念

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

面试题：实现一个类，计算程序中创建出了多少个类对象。

class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }
private:
static int _scount;
};
int A::_scount = 0;
void TestA()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}
class Date
{
public:
Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}

2.特性

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

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

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

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

5. 静态成员也是类的成员，受 public 、 protected 、 private 访问限定符的限制

三. 友元

1.概念

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

友元分为： 友元函数 和 友元类

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

2.说明

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

友元函数 不能用 const 修饰

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

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

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

四. 内部类

概念： 如果一个类定义在另一个类的内部，这个内部类就叫做内部类 。内部类是一个独立的类， 它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越 的访问权限。

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

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

3. sizeof(外部类)=外部类，和内部类没有任何关系 。

五.匿名对象

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

六.拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的

七. 再次理解封装

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现 实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序创建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：

1. 用户先要对现实中洗衣机实体进行抽象---即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程

2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清

楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、

Java、Python等)将洗衣机用类来进行描述，并输入到计算机中

3. 经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣 机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才 能洗衣机是什么东西。

4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。

在类和对象阶段，大家一定要体会到， 类是对某一类实体 ( 对象 ) 来进行描述的，描述该对象具有那 些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例  具体的对象 。

---

总结

类和对象是面向对象编程的重要概念，它们的作用如下：

1. 封装和抽象：类是对一类事物的抽象和封装，它包含了对象的属性和行为。通过类的定义，可以将相关的属性和方法组织在一起，形成一个模板或蓝图，方便程序员进行代码的编写和维护。

2. 实例化对象：对象是类的实例化，通过创建对象可以根据类的模板来生成实际的数据。对象具有类的属性和行为，并可以通过调用对象的方法来实现相应的功能。

3. 模块化和重用：类和对象的使用可以实现代码的模块化和重用。通过将相关的属性和方法封装在类中，可以将代码块分为多个模块，提高代码的可读性和可维护性。同时，可以通过创建不同的对象来实现对同一类代码的重用。

4. 继承和多态：通过类的继承和多态机制，可以实现代码的复用和扩展。继承允许一个类继承另一个类的属性和方法，并可以在其基础上进行修改和扩展。多态允许不同的对象对同一消息做出不同的响应，提高了代码的灵活性和可扩展性。

5. 数据和功能的关联：类和对象的结合可以将数据和功能关联在一起。类的属性可以存储对象的状态信息，方法可以用来操作和处理这些数据。这种关联性使得代码更加可靠和易于理解，同时也能提高程序的效率和性能。

总之，类和对象是面向对象编程的核心概念，通过类和对象的使用可以实现代码的模块化和重用，提高代码的可读性和可维护性，同时也增加了代码的灵活性和扩展性。