[C++]——带你学习类和对象

关注

原创最新推荐文章于 2026-05-28 21:49:02 发布 1.8k 阅读 AI 写同款· GEO 优化 ›

[C++中类与对象 cpp] -＞ C++面向对象编程进阶：深入学习类与对象在C++中，我们需要使用class关键字来定义一个类。类的定义包含了类的成员变量和成员函数。成员函数可以是公有(public)的、私有(private)的或受保护(protected)的。公有成员可以在类外部被访问，私有成员只能在类内访问，受保护成员可以在类及其子类中访问。public:// 公有成员函数private:// 私有成员变量int age; 阅读详情

一、构造函数补充

1.1构造函数初始化

在这里插入图片描述

构造函数体中的语句只能将其称为赋初值，而不能称作初始化，因为初始化只能初始化一次，而构造函数体内可以多次赋值。（默认构造有3个，系统默认生成的构造函数，无参的构造函数，全缺省的构造函数）

1.2构造函数初始化列表

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

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
//日期类
class Time
{
public:
    //初始化列表
    Time(int hour=1,int minute=1,int secnd=1)
        :_hour(hour),
        _minute(minute),
        _second(secnd)
    {}
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
    //公有
public:
    Date(int year=1970, int month=1, int day=1)
        :_year(year),
        _month(month),
        _day(day),
        time()
    {
    }
//私有
private:
    int _year;
    int _month;
    int _day;
    Time time;
    const static size_t npos=-1;//静态变量加个const，这是一个特例，需要特殊处理，可以给缺省值，但是这个数必须是整型
};
int main()
{
    Date d;
    Date d3(2023, 11, 25);
    return 0;
}

初始化列表解决的问题：
1——每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）。
2——引用，const，没有默认构造函数的自定义成员，必须在初始化列表中显示定义。，有些自定义类型成员想要自己控制，也尽量使用初始化列表来初始化。
缺省值相当于是给初始化列表；如果自定义类型成员去调用它的默认构造函数，内置类型初始化，值是随机值。
3——构造函数不能只要初始化列表不要函数体赋值，他们可以混合着用。
4——初始化列表就是成员函数定义的地方，建议声明顺序和初始化列表一致，避免出现理解问题。

1.3explicit关键字

单参数的情况（c++98支持）

#include <iostream>
using namespace std;
class Date
{
    //公有
public:
  Date(int year , int month = 1, int day = 1)
        :_year(year),
        _month(month),
        _day(day)
    {
    }
  //加上explicit关键字，禁止构造函数发生隐式转换
 /* explicit Date(int year, int month = 1, int day = 1)
      :_year(year),
      _month(month),
      _day(day)
  {
  }*/
    //私有
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2024);//构造函数
    //只要是类型转换就会生成临时变量，临时变量具有常属性。
    Date d2=2024;//构造函数+拷贝构造+优化——>构造函数（发生了隐式类型转化）//c++98
    return 0;
}

多参数的情况（c++11支持）

#include <iostream>
using namespace std;
class Date
{
    //公有
public:
    Date(int year, int month=1 , int day = 1)
        :_year(year),
        _month(month),
        _day(day)
    {
    }
    //加上explicit关键字，禁止构造函数发生隐式转换
   /* explicit Date(int year, int month = 1, int day = 1)
        :_year(year),
        _month(month),
        _day(day)
    {
    }*/
    //私有
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2024,2);//构造函数
    Date d2 = { 2024,3 };//构造函数+拷贝构造+优化——>构造函数（发生了隐式类型转化）//c++11
    return 0;
}

总结：

1——对于单个参数或者除第一个参数无默认值其余参数有默认值的构造函数，具有类型转换（强制类型转换）的作用。
2——用explicit关键字修饰构造函数，将会禁止构造函数发生隐式转换。

二、Static成员(静态成员变量，静态成员函数)

static修饰的成员变量，不走初始化列表，需要在类外定义（声明和定义必须分离）
静态成员变量定义：

int Date::sum=0;

静态成员函数定义：

int Date::add()
{
//…………
}

需要记住：
static修饰类成员的特性：

1——静态成员为所有类对象所共享，不属于某个具体的类，存放在静态区。
2——静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。
3——类静态成员可以用类名::静态成员或者对象.静态成员来访问。
4——静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
5——静态成员也是类的成员，受public、protected、private访问限定符影响。
6——静态成员变量和静态成员函数本质上是受限制的全局变量和全局函数。（专属这个类，受类域和访问限定符的限制）

三、友元

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

3.1友元函数

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

问题:
尝试去重载operator<<,然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。
解决方案：
所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

#include <iostream>
using namespace std;
class Date
{
    //声明友元函数
     friend ostream& operator<<(ostream& _count,Date& b);
    //公有
public:
    //初始化列表
    Date(int year,int month,int day)
        :_year(year),
        _month(month),
        _day(day)
    {}
    //私有
private:
    int _year;
    int _month;
    int _day;
};
ostream& operator<<(ostream& _count,Date& b)
{
   return  _count << b._year << "年" << b._month << "月" << b._day << "日";
}
int main()
{
    Date d(1970, 1, 1);
    cout << d ;
    return 0;
}

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

3.2友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
1——友元关系是单向的，不具有交换性。
比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
2——友元关系不能传递。
如果C是B的友元，B是A的友元，则不能说明C时A的友元。
3——友元关系不能继承。

注意：

友元是一种突破封装的方式，会增加耦合度，不易多用。
高耦合：出了错误，全部都错。
低耦合：出了错误，个别程序还能跑。

四、内部类

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

#include <iostream>
using namespace std;
class A
{
public:
    //内部类
    class B
    {
    public:
        void fun(const A& c)
        {
            cout << c.a << endl;
            cout << _a << endl;
            cout << b << endl;
        }
    private:
        int b = 3;
    };
private:
    int a=1;
    static int _a;
};
int A::_a = 2;
int main()
{
    A::B b;
    b.fun(A());//A()是匿名对象，生命周期只能在这一行
    return 0;
}

特性:
1.内部类可以定义在外部类的public、protected、 private都是可以的。
2.注意内部类可以直接访问外部类中的static成员，不需要外部类的对象或者类名。
3.sizeof(外部类)=外部类，和内部类没有任何关系。

五、匿名对象

 A aa()//不能这样定义对象，编译器无法识别这是函数声明还是对象定义。
 //匿名对象生命周期只在这一行，下一行它就会自动调用析构函数，定义如下：
 A();
 A().Sum(1,2);

临时对象和匿名对象生命周期只有一行。

六、拷贝构造时的编译器优化

在传参和传返回值的过程中，编译器会做一些优化，减少对象的拷贝。
这些优化，不同的编译器可能结果不同。
隐式类型：连续构造+拷贝构造——>优化为直接构造

//先用1构造一个临时对象，在用临时对象拷贝构造aa，直接被优化成构造。
//不发生优化,拷贝一个临时变量，给它取别名。
const A& aa1=2;
A aa=1；

优化的前提——同一个步骤里。

优化的方式：

构造+构造——>构造
构造+拷贝构造——>构造
拷贝构造+拷贝构造——>拷贝构造
例子：
A f()
{
A aa;
return aa;
}
A aa1=f();

七、在次理解类和对象

举个例子：
我们如何让计算机去描述洗衣机

1.用户先要对现实中洗衣机实体进行抽象——即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程。
2。经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面向对象的语言(比如:C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中。
3.经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4.用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。

学习类和对象，我们一定要体会到：类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，使用用该自定义类型就可以实例化具体的对象。