C++初阶--类和对象（中）

最新推荐文章于 2024-06-22 21:53:36 发布
最新推荐文章于 2024-06-22 21:53:36 发布
阅读量321 收藏 4
点赞数 5
分类专栏： C++初阶 文章标签： c++ 数据结构 算法 开发语言 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75233943/article/details/132336256
版权

目录


上篇末尾我们讲到了关于c++实现栈相较于c语言在传递参数时的一些优化，但实际上，c++在 初始化 清理 赋值 拷贝等方面也做了很大程度的优化，本篇文章我们将研讨c++的几个 默认成员函数。

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时**，编译器会自动生成以下6个默认成员函数。**
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

构造函数

我们先来看之前写过的日期类

class Date
{
public:
 void Init(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 d1.Init(2022, 7, 5);
 d1.Print();
 Date d2;
 d2.Init(2022, 7, 6);
 d2.Print();
 return 0;
}

对于Date类，可以通过 Init 公有方法给对象设置日期**，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦**，那能否在对象创建时，就将信息设置进去呢？
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
特征如下
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

使用方法

构造函数分为两种：
1, 无参构造函数
2，带参构造函数

class Date
{
public:
	Date()
	{}

	Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Test1()
{
	Date d1(2023,8,17);
	d1.Print();

	Date d2;
	d2.Print();
}

int main()
{
	Test1();
	return 0;
}

打印结果如下

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

  class Date
 {
  public:
 /*
 // 如果用户显式定义了构造函数，编译器将不再生成
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 */
 
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }
  
  private:
 int _year;
 int _month;
 int _day;
 };
  
  int main()
 {
 // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
数
 // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
生成
      // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
 Date d1;
 return 0;
 }

关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默
认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数。

class Time
{
public:
 Time()
 {
 cout << "Time()" << endl;
 _hour = 0;
 _minute = 0;
 _second = 0;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year;
 int _month;
 int _day;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date()
	{}

	Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;

	Time _t;
};

void Test1()
{
	Date d1(2023,8,17);
	d1.Print();

	Date d2;
	d2.Print();
}

int main()
{
	Test1();
	return 0;
}

打印结果如下

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数。

析构函数

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

使用方法

析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意**：析构函数不能重载**
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

我们以栈为例

typedef int DataType;
class Stack
{
public:
 Stack(size_t capacity = 3)
 {
 _array = (DataType*)malloc(sizeof(DataType) * capacity);
 if (NULL == _array)
 {
 perror("malloc申请空间失败!!!");
 return;
 }
 _capacity = capacity;
 _size = 0;
 }
 void Push(DataType data)
 {
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }
 // 其他方法...
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = NULL;
 _capacity = 0;
 _size = 0;
 }
 }
private:
 DataType* _array;
 int _capacity;
 int _size;
};
void TestStack()
{
 Stack s;
 s.Push(1);
 s.Push(2);
}

关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数。

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}

	~Time()
	{
		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;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

	Time _t;
};

void Test1()
{
	Date d1(2023,8,17);
	d1.Print();

	Date d2;
	d2.Print();
}

int main()
{
	Test1();
	return 0;
}

打印结果如下

注意：如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

拷贝构造函数

只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

使用方法

拷贝构造函数也是特殊的成员函数，其特征如下：

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。

我们来看下面这段代码：

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
}
// Date(const Date& d)//正确写法
Date(const Date d) // 错误写法:编译报错，会引发无穷递归 {
        _year = d._year;
        _month = d._month;
        _day = d._day;
} private:
    int _year;
    int _month;
    int _day;
};
int main() {
    Date d1;
    Date d2(d1);
    return 0;
    ｝

为什么Date(const Date d)会引发无穷递归呢？
这是因为当我们传值调用会引发对对象d的拷贝，然后又会调用拷贝构造函数，在调用时又会引发对象拷贝，这样就会无限循环下去，但如果我们采取传引用的方法，形参和实参是同一个对象，就不会引发调用拷贝构造。

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
Time() {
        _hour = 1;
        _minute = 1;
        _second = 1;
}
    Time(const Time& t)
    {
        _hour = t._hour;
        _minute = t._minute;
        _second = t._second;
        cout << "Time::Time(const Time&)" << endl;
} private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
// 基本类型(内置类型) int _year = 1970; int _month = 1; int _day = 1;
// 自定义类型
Time _t; };
int main() {
Date d1;
// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构 造函数
Date d2(d1);
return 0; }

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。

那么，既然编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己来显示实现吗？
答案是肯定的 ，这是因为对于日期类这种内置类型的类是没有必要自己写的，但是像栈，堆这种需要动态申请资源的类就需要自己显示实现。如果我们不写，系统会默认调用自带的成员函数，也就是浅拷贝，

那么为什么浅拷贝不行而必须要深拷贝呢？
这是因为如果我们使用浅拷贝，也就是值传递，那么原对象中的内容会原封不动拷贝到新对象中去，如果里面有类似指针类型的这种成员变量，那么它们将会指向同一块空间，在析构时就会对同一块空间释放两次，从而导致程序崩溃。在这里插入图片描述
拷贝构造函数典型调用场景:
·使用已存在对象创建新对象
·函数参数类型为类类型对象
·函数返回值类型为类类型对象<\font>
看下面这段代码：

class Date
{
public:
    Date(int year, int minute, int day)
    {
        cout << "Date(int,int,int):" << this << endl;
    }
    Date(const Date& d)
    {
        cout << "Date(const Date& d):" << this << endl;
    }
~Date() {
        cout << "~Date():" << this << endl;
    }
private:
    int _year;
int _month;
int _day; };
Date Test(Date d)
{
    Date temp(d);
    return temp;
}
int main() {
    Date d1(2022,1,13);
    Test(d1);
    return 0;
｝

赋值运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为: 关键字operator后面接需要重载的运算符符号。
函数原型:返回值类型 operator操作符(参数列表)
注意:
不能通过连接其他符号来创建新的操作符:比如operator@
重载操作符必须有一个类类型参数 用于内置类型的运算符，其含义不能改变，例如:内置的整型+，不 能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
注意以下5个运算符不能重载。这个经常在笔试选择题中出现。
.* :: sizeof ?: .

看下面这段代码：

// 全局的operator== class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
}
//private:
    int _year;
    int _month;
    int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证? // 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
        && d1._month == d2._month
        && d1._day == d2._day;
}
void Test () {
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout<<(d1 == d2)<<endl;
}
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
_day = day; }
// bool operator==(Date* this, const Date& d2) // 这里需要注意的是，左操作数是this，指向调用函数的对象 bool operator==(const Date& d2)
{
        return _year == d2._year;
            && _month == d2._month
            && _day == d2._day;
} private:
    int _year;
    int _month;
    int _day;
};

赋值运算符重载

赋值运算符重载格式
·参数类型:const T&，传递引用可以提高传参效率 ·返回值类型:T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
·检测是否自己给自己赋值
·返回*this :要复合连续赋值的含义

class Date
{
public :
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
}
    Date (const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._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 ;
};

赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:
   Date(int year = 1900, int month = 1, int day = 1)
   {
       _year = year;
       _month = month;
       _day = day;
}
   int _year;
   int _month;
   int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数 Date& operator=(Date& left, const Date& right)
{
   if (&left != &right)
   {
       left._year = right._year;
       left._month = right._month;
       left._day = right._day;
}
   return left;
}
// 编译失败:
// error C2801: “operator =”必须是非静态成员

原因:赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

还需注意的是，赋值运算符重载函数和拷贝构造函数类似，在调用需要动态申请内存空间的类时，需要自己显示实现，否则会使用编译器默认的赋值运算符重载函数进行值拷贝，最终同一块空间又将被析构两次。

typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 10)
    {
        _array = (DataType*)malloc(capacity * sizeof(DataType));
        if (nullptr == _array)
        {
perror("malloc申请空间失败");
return; }
  
注意:如果类中未涉及到资源管理，赋值运算符是否实现都可以;一旦涉及到资源管理则必
须要实现。
  _size = 0;
        _capacity = capacity;
    }
    void Push(const DataType& data)
    {
        // CheckCapacity();
        _array[_size] = data;
_size++; }
~Stack() {
if (_array) {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
} }
private:
    DataType *_array;
    size_t _size;
    size_t _capacity;
};
int main()
{
    Stack s1;
    Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2;
    s2 = s1;
    return 0;
    ｝

在这里插入图片描述

const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数 隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
在这里插入图片描述
还需注意以下几点：
1.const对象不能调用非const成员函数。（权限放大）
2.非const对象可以调用const成员函数。（权限缩小）
3.const成员函数内不能调用其他非const成员函数。（权限放大）
4.非const成员函数内可以调用其他const成员函数。（权限缩小）

偷吃橙子的喵
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C++实验一-类与简单对象.doc
11-15
C++实验一-类与简单对象 本实验报告的主要目的是让学生理解类和对象的概念...本实验报告的目的是让学生理解和掌握 C++面向对象程序设计的基本思想、基本方法和基本步骤，并掌握类和对象的概念、定义方法和实现方法。
C++类和对象应用 - 日期类
02-07
一份完善的日期类源码
C++初阶-类和对象中
~
12-14 398
C++类和对象一、前言二、类的6个默认成员函数汇总三、构造函数四、析构函数五、拷贝构造函数六、赋值运算符重载1、运算符重载2、赋值运算符重载七、日期类的实现八、const成员九、取地址及const取地址操作符重载 一、前言 本章是继C++类和对象启点之章的后续，进一步深入学习掌握C++类和对象 二、类的6个默认成员函数汇总 对于任何一个类来说，在我们不主动写默认成员函数时，会自动生成默认成员函数，总共有6个默认成员函数 汇总示图： 三、构造函数 引入： 在C语言数据结构时，创建结构变量我
C++初阶--类和对象
weixin_74792326的博客
05-23 776
1、声明和定义全部都放在类体中，但是需要注意的是如果在类中定义，编译器可能会将其当成内联函数处理。2、类声明在.h文件中，成员函数定义放在.cpp文件中。但是在.cpp中要在成员函数前面加*一般情况下推荐第二种。
C++初阶-类和对象上
~
12-06 1433
类和对象-起点之章一、前言二、面向过程/对象区别三、类的引入四、类的定义五、类的访问限定符及封装1、访问限定符2、封装六、类的作用域七、类的实例化八、类对象模型1、类对象的大小计算2、结构体内存对齐规则九、this指针1、this指针引入2、this指针的特性3、相关面试题 一、前言 主要讲解点： 本章将开启C++类和对象的学习和讲解，这里是起点之章，为之后的深入掌握类和对象打基础 二、面向过程/对象区别 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C+
C++初阶---类和对象
weixin_63219391的博客
03-23 829
本文介绍了C++中的类和对象，类的访问限定符，封装，作用域，实例化包含六个默认函数，操作符的重载，const成员和static成员，友元函数和友元类，内部类等
C++初阶-类和对象下
~
12-19 361
C++类和对象-最终之章（下）零、前言一、再谈构造函数1、构造函数体赋值2、初始化列表3、explicit关键字二、static成员三、C++11 新式成员初始化四、友元1、友元函数2、友元类五、内部类六、再次理解封装七、再次理解面向对象 零、前言 本章为C++类和对象的最后一章，将类和对象的知识进一步学习和掌握 一、再谈构造函数 1、构造函数体赋值 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值 示例： class Date { public: Date(int.
C++初阶---类和对象(入门)
qq_41420788的博客
10-09 315
类和对象1）面向过程与面向对象2）类①类(class)的引入和定义引入定义②类的访问1. (初识)类的访问限定符2. 类的作用域3. 面向对象的三大特性之一：封装③类的实例化和对象模型实例化1. 计算类对象的大小2. 类对象的存储方式3. 结构体内存对齐规则3）this指针概念this指针的一些问题 1）面向过程与面向对象 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成 （注意: C
c++初阶------类和对象(下)
m0_69984273的博客
03-12 1109
​🎂 作者介绍： 🎂🎂🎂作者id：老秦包你会， 🎂简单介绍：🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂喜欢学习C语言、C++和python等编程语言，是一位爱分享的博主，有兴趣的小可爱可以来互讨 🎂🎂🎂🎂🎂🎂🎂🎂。
C++初阶--类和对象（下）
microlovw的博客
04-29 422
当创建const变量，调用函数时，会报错，权限放大的问题我们可以在函数后加const使this变成const的 void Date :: Print () const 这个const修饰的是*this。3.若未显式定义，编译器会生成默认的拷贝构造函数。友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。传值返回， 先构造一个临时的后定义的先析构全局的，main函数之前就构造了 静态变量，第一次调用时才会构造。
C++初阶--类和对象（上）
weixin_67916525的博客
04-03 268
/ 类体：由成员函数和成员变量组成// 一定要注意后面的分号class为定义类的关键字ClassName为类的名字{}中为类的主体，注意类定义结束时后面分 号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内 联函数处理（符合inline条件,编译指令比较少）。
C++初阶 - 入门.pdf
01-15
C++是C语言的超集，添加了对象导向编程的特性，使得编程更加灵活和高效。 1. C++98标准 C++98是C++语言的第一个国际标准，发布于1998年。这个标准规定了C++语言的语法、词汇和语义，使得C++语言变得更加标准化和可...
C++入门-初识类与对象
10-22
思维导图
C++程序设计基础课件第-讲类和对象完美版资料.ppt
11-14
C++程序设计基础课件第-讲类和对象完美版资料.ppt 本资源摘要信息涵盖了C++程序设计基础课件第-讲类和对象的主要内容，包括类的定义、对象的定义、对象的初始化、成员函数的特性、静态成员、友元、局部类和嵌套类等...
C的I/O操作
weidl001的博客
06-17 734
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
LeetCode 算法：排序链表 c++
最新发布
小金牛来了
06-22 538
LeetCode 算法：排序链表 c++
C/C++ 提取DNS请求/响应数据包之中的 Quesion 内容
liulilittle的博客
06-20 233
它主要是提取DNS数据包之中查询问题的信息，如：问题类型、问题类别、问题内容（域/IP），我们如果想要对于某个DNS数据包需要进行遥测的时，或者进行NS缓存生命周期管理，那么就需要类似这样的函数实现了。
STL中vector、list、map和set的主要区别
2402_84885073的博客
06-16 338
在C++的STL（Standard Template Library）中，是四种常用的容器，它们各自具有不同的特性和用途。
c++面向对象-类和对象的创建和使用
08-12
C++是一种面向对象的编程语言，它支持类和对象的创建和使用。类是一种用户定义的数据类型，它封装了数据和方法，可以用来描述一个实体的属性和行为。对象是类的实例，它具有类定义的属性和行为。 在C++中，可以通过定义类来创建对象。类的定义包括成员变量和成员函数，成员变量用于存储对象的数据，成员函数用于操作对象的数据。可以使用访问修饰符来控制成员变量和成员函数的访问权限，包括public、private和protected。 创建对象时，需要使用类的构造函数来初始化对象的成员变量。构造函数是一种特殊的成员函数，它在对象创建时自动调用，用于初始化对象的数据。可以定义多个构造函数，以支持不同的对象初始化方式。 使用对象时，可以调用对象的成员函数来操作对象的数据。成员函数可以访问对象的成员变量，也可以调用其他成员函数。可以使用点运算符来访问对象的成员，包括成员变量和成员函数。 总之，C++的面向对象编程提供了类和对象的创建和使用，可以用于描述实体的属性和行为，实现代码的封装和复用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偷吃橙子的喵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值