C++类和对象（中）

原创 已于 2025-09-03 15:27:48 修改 · 863 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

于 2025-05-23 22:53:21 首次发布

目录

1.类的六个默认成员函数

2.构造函数

3.析构函数

4.拷贝构造函数

 5.赋值运算符重载

6.日期类的实现

7.const成员

1.类的六个默认成员函数

如果一个类中什么成员都没有，简称为空类。

class Date
{
};

任何类在什么都不写的情况下，编译器会自动生成以下六个默认成员函数（用户没有显式实现，编译器会生成的成员函数）。

2.构造函数

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时编译器自动调用。保证每个成员变量都有一个合适的初始值，并且在对象整个生命周期只调用一次。

构造函数的主要任务不是开空间创建对象，而是初始化对象。

其特征如下：

  1. 函数名与类名相同
  2. 无返回值，无需写void
  3. 对象实例化时编译器自动调用对应函数
  4. 构造函数可以重载，但无参调用存在歧义
class Date
{
public:
// 1.无参构造函数
Date()
{}
// 2.带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void TestDate()
{
Date d1; // 调用无参构造函数
Date d2(2015, 1, 1); // 调用带参的构造函数
// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
// warning C4930: “Date d3(void)”: 未调用原型函数
Date d3();//错误，这里是函数声明，未实例化对象！
}

     5.如果类中没有显式定义构造函数，则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;
}

注：内置类型（例如int,char,float，指针类型等）不做处理

但是注意

1.很少有些编译器会处理

2.C++打了补丁，内置类型成员变量在类中声明时可以给默认值,
给了缺省值会初始化

自定义类型（例如struct,class，union等）会调用它的默认构造 

所以一般情况下，有内置类型成员，就需要自己写析构函数，不能用编译器自己生成的。如果全都是自定义类型成员，可以考虑让编译器自己生成

总结：

  1. 一般构造函数都需自己写
  2. 编译器自己生成：a）内置类型成员都有缺省值且初始化符合要求                                                                         b）全为自定义类型的构造，且这些类型的定义都默认构造
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 = 1970;
int _month = 1;
int _day = 1;//缺省值，不是初始化，只是声明
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}

  6.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数(不传参就可调用的）

class Date
{
public:
Date()
{
_year = 1900;
_month = 1;
_day = 1;
}
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
// 以下测试函数编译失败，类中存在多个默认构造函数，导致调用Date d1时出现二义性。
void Test()
{
Date d1;
}

3.析构函数

析构函数：与构造函数功能相反，不是完成对对象本身的销毁，局部对象的销毁工作由编译器完成。而是对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

其特征如下：

  1. 函数名是在类名前加上字符~
  2. 无参数无返回类型
  3. 一个类只能有一个析构函数，若未显式定义，系统会自动生成默认的析构函数。（注意：内置类型成员不做处理，自定义类型会调用它的析构函数）
  4. 析构函数不能重载
  5. 对象生命周期结束的时候，C++编译系统自动调用析构函数。

总结：

1.一般情况下有动态申请资源，一定要写析构函数释放资源，否则造成内存泄露（如Stack类）。

2.没有动态申请的资源或者需要释放资源的成员都是自定义类型，不需要写析构函数 （如Date类）。

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

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

class Time
{
public:
~Time()
{
cout << "~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 d;
return 0;
}

程序运行结束后输出：~Time()

Q:在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
A:因为main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,_day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁

总而言之就是main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数 

构造顺序是按照语句的顺序进行构造，析构是按照构造的相反顺序进行析构 看下面这道题来深度理解一下。

1、类的析构函数调用一般按照构造函数调用的相反顺序进行调用，但是要注意static对象的存在， 因为static改变了对象的生存作用域，需要等待程序结束时才会析构释放对象

 2、全局对象先于局部对象进行构造

 3、局部对象按照出现的顺序进行构造，无论是否为static

 4、所以构造的顺序为 c a b d

 5、析构的顺序按照构造的相反顺序析构，只需注意static改变对象的生存作用域之后，会放在局部 对象之后进行析构

 6、因此析构顺序为B A D C

4.拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰），再用已存在的类类型对象创建新对象时由编译器自动调用。C++规定，内置类型直接拷贝，自定义类型必须调用拷贝构造函数完成拷贝。

其特征如下：

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

   3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按

字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。内置类型成员完成值拷贝/浅拷贝，自定义类型成员会调用它的拷贝构造

   4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？

像日期类这样的类是没必要的。那么下面的类呢？

// 这里会发现下面的程序会崩溃掉，这里就需要我们以后讲的深拷贝去解决。
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;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2(s1);
return 0;
}

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；
一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

  5.经典调用拷贝构造函数场景

  1. 使用已存在对象创建新对象
  2. 函数参数类型为类类型对象
  3. 函数返回值类型为类类型对象
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;
}

传值返回会产生一个临时对象，调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝，不会调用拷贝构造。

但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返回。

 5.赋值运算符重载

1）运算符重载

C++为了增强代码的可读性，引入了运算符重载，运算符重载是具有特殊函数名的函数。函数名为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator 操作符（参数列表）

注：

  1. 不能通过连接其他符号来创建新的操作符
  2. 重载操作符必须有一个类类型参数
  3. 用于内置类型的运算符，其含义不能改变
  4. 作为类成员的重载时，其形参看起来比操作数数目少一，因为成员函数的第一个参数为隐藏的this。
  5. .*   ::   sizeof   ?:   .以上五个运算符不能重载（笔试常考）
  6. 操作符有几个操作数，重载函数就有几个参数
// 1.
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;
}

//2
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;
}
void Test ()
{
Date d1(2018, 9, 26);
Date d2(2018, 9, 27);
cout<<(d1 == d2)<<endl;//第一种情况相当于operator(d1,d2)，第二种情况相当于d1.operator(d2)
}

2）赋值运算符重载

i）赋值运算符重载格式

  1. 参数类型：const T&，传递引用可以提高传参效率
  2. 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  3. 检测是否自己给自己赋值
  4. 返回*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 ;
}

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

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 =”必须是非静态成员

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

iii）用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值

总结：默认生成赋值重载跟拷贝构造行为一样

1.内置类型成员——值/浅拷贝

2.自定义类型会调用它的赋值重载

例如：Date和MyQueue不需我们实现，stack需要，因为默认生成浅拷贝，同一块空间会析构两次  

3.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

6.日期类的实现

//date.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
using namespace std;
class Date
{
public:
	// 获取某年某月的天数
	int GetMonthDay(int year, int month);
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1);
	// 拷贝构造函数
  // d2(d1)
	Date(const Date& d);
	// 赋值运算符重载
  // d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d);
	// 析构函数
	~Date();
	// 日期+=天数
	Date& operator+=(int day);
	// 日期+天数
	Date operator+(int day);
	// 日期-天数
	Date operator-(int day);
	// 日期-=天数
	Date& operator-=(int day);
	// 前置++
	Date& operator++();
	// 后置++
	Date operator++(int);
	// 后置--
	Date operator--(int);
	// 前置--
	Date& operator--();
	// >运算符重载
	bool operator>(const Date& d);
	// ==运算符重载
	bool operator==(const Date& d);
	// >=运算符重载
	bool operator >= (const Date& d);
	// <运算符重载
	bool operator < (const Date& d);
	// <=运算符重载
	bool operator <= (const Date& d);
	// !=运算符重载
	bool operator != (const Date& d);
	// 日期-日期 返回天数
	int operator-(const Date& d);
	void Print();
private:
	int _year;
	int _month;
	int _day;
};
//date.cpp
#include"date.h"
int Date::GetMonthDay(int month, int year)
{
		static int days[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		//写成静态数组，就不需要每次都创建数组了，作用域为全局
		if (month == 2 && (year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
		{
			return 29;
		}
		return days[month];
}
Date::Date(int year, int month , int day)
{
	if (month > 0 && month <= 12  && day > 0 && day <= GetMonthDay(month,year))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		cout<< "非法日期" << endl;
		assert(false);
	}
}
// 拷贝构造函数
// d2(d1)
Date::Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
// 赋值运算符重载
// d2 = d3 -> d2.operator=(&d2, d3)
Date& Date::operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}
// 析构函数
Date::~Date()
{
	cout << "~Date()" << endl;
}
// 日期+=天数
Date& Date::operator+=(int day)
{ 
	if (day < 0)
		return *this -= -day;
		_day += day;
		while (_day > GetMonthDay(_month, _year))
		{
			_month++;
			_day -= GetMonthDay(_month, _year);
			if (_month > 12)
			{
				_year++;
				_month = 1;
			}
		}
	return*this;
}
// 日期+天数
Date Date::operator+(int day)
{
	Date tmp=*this;
	*this += day;
	return tmp;
}
// 日期-天数
Date Date::operator-(int day)
{
	Date tmp = *this;
	*this -= day;
	return tmp;
}
// 日期-=天数
Date& Date::operator-=(int day)
{
	if (day < 0)
		return *this += -day;
	_day -= day;
	while (_day < 0)
	{
		--_month;
		if(_month == 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_month, _year);
	}
	return *this;
}
// 前置++
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
// 后置++
Date Date::operator++(int)
{
	Date tmp = *this;
	*this += 1;
	return tmp;
}
// 后置--
Date Date::operator--(int)
{
	Date tmp = *this;
	*this -= 1;
	return tmp;
}
// 前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}
// >运算符重载
bool Date::operator>(const Date& d)
{
	return !(*this <= d);
}
// ==运算符重载
bool Date::operator==(const Date& d)
{
	return (_year == d._year) && (_month == d._month)&&( _day == d._day);
}
// >=运算符重载
bool Date::operator >= (const Date& d)
{
	return !(*this < d);
}
// <运算符重载
bool Date::operator < (const Date& d)
{
	if (_year < d._year)return true;
	else if (_year == d._year)
	{
		if (_month < d._month) return true;
		else if (_month == d._month)
		{
			if (_day < d._day)return true;
		}
	}
	return false;
}
// <=运算符重载
bool Date::operator <= (const Date& d)
{
	return *this < d || *this == d;
}
// !=运算符重载
bool Date::operator != (const Date& d)
{
	return !(*this == d);
}
// 日期-日期 返回天数
int Date::operator-(const Date& d)
{
	Date max = *this;
	Date min = d;
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}
	return n * flag;
}
void Date::Print()
{
	cout << _year << "-" << _month << "-" << _day << endl;
}

7.const成员

被const修饰的成员函数是const成员函数，实际修饰的是该成员函数隐含的this指针，在该成员函数中不能对类的任何成员进行修改。

成员函数后加const后，普通和const对象都可调用。

但不是所有成员函数都可加这个const，要修改的对象成员变量函数不能加，只要成员函数内部不修改成员变量都应该加const。这样普通和const对象都能调用。

8.取地址及const取地址操作符重载

两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容

总结一下如何在测试中调用以上的函数：

  • 构造函数：直接通过 类名(参数) 创建对象。
  • 成员函数：通过 对象.函数名(参数) 调用（因为成员函数属于对象）。
  • 友元运算符：作为全局函数，直接通过 运算符 对象 调用（如 cout << 对象、cin >> 对象）。
  • 赋值运算符：作为特殊的成员函数，通过 对象1 = 对象2 调用。

C++ 类对象初始化
鲸落博客
05-01 2007
当创建一个类的实例时，如果没有定义构造函数，系统会自动生成一个无参构造函数，并自动初始化成员变量。内置类型的变量（如int、double、指针等）会被初始化为一个未定义的值，而自定义类型的变量（如类、结构体）会调用默认构造函数进行初始化。
C++类和对象，思维导图
04-24
C++类和对象，会跟着文章更新而更新
C++类和对象超详细
C/C++学习之旅
02-09 5938
本文对C++类和对象的知识进行了详细的介绍,构造析构拷贝构造等成员函数,以及友元,内部类,等等
C++类和对象（一）
ll1175555的博客
07-13 1万+
目录面向过程和面向对象初步认识类的定义类的作用域类的实例化类的访问限定符及封装类的对象大小计算类成员函数this指针 面向过程和面向对象初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 比如一个外卖系统 面向过程：下单、接单、送餐三个过程 面向对象：客户、商家、骑手，关注的是三个类对象之间的关系 类的定义 class Name { //类体:由成员函数和成员变量组成
C++ 类和对象
Allelujah123的博客
03-14 1822
类和对象 目录 类和对象 面向过程和面向对象的区别 类和对象 定义类的格式 定义类的方式​ 类的作用域 面向对象特性 封装 C++程序设计中是如何体现封装性的 访问限定符 类的实例化 类的大小 this指针 this指针的特性 汇编角度来看this 函数参数调用约定 this指针的存放位置 This指针是否可以为空 面向过程和面向对象的区别 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 ...
c++类和对象（类的概念）
m0_58103115的博客
03-24 6571
1.类和对象概念 类：用来对实体（对象）进行描述，对象有什么属性，以及对象具有什么功能是一种自定义类型 对象：现实生活中所存在的 ，对象是对类的具体体现 用类类型创建出来的变量称为对象 2.类的定义 class[类名] { //类体：成员变量属性，成员变量功能 } 方法一：将类的声明和定义全部放在类中定义 方法二：在头文件中放类的声明，在源文件中放类的定义 5.类的访问限定符及封装 6.类的对象大小计算 7.类成员对象的this指针 ...
C++_类和对象
Mr___Blue的博客
04-18 2369
快速帮助了解学习C++中类和对象的基本概念
【C++】(二) 类和对象的定义与使用
记录学习成长之路，进一寸有进一寸的欢喜
06-11 4441
  建议先看完上面那篇博客。这篇博客主要讲述C++中类和对象的定义与使用。  先介绍一些概念，建立理论印象。  所谓对象，其实就是用来描述客观事物的一个实体，比如一辆汽车就是一个对象。描述一个对象时，一般会从它的属性和行为两方面来展开，其中，属性可以认为是对象的静态特征，一些数据；而行为可以认为是对象的动态特征，对应的操作等。   而类，是具有相同属性和服务的一组对象的集合，它是属于该类的全部对象的一个抽象描述，因此同样具有属性和行为两部分，但这里更多的是抽象的概念。   类和对象的关系犹如模具和铸件之间的
C++类和对象——(5)定义对象数组
一个正在学习C/C++的博主
12-03 2408
类和对象——(5)定义对象数组
C++类和对象的使用之对象指针
热门推荐
low5252的博客
07-04 2万+
类和对象的使用之对象指针 对象指针的一般概念 对象指针：指向类的成员的指针。在C++中，可以说明指向类的数据成员和成员函数的指针。 对象指针遵循一般变量指针的各种规则：类名 *对象指针名； 对象指针名*成员名； 对象指针在使用之前，也一定要先进行初始化，让它指向一个已经声明过的对象，然后再使用。通过对象指针，可以访问到所指向对象的公有成员。 指向对像的指针 在建立对像时，编译系统会为每一个对像分配...
C++类与对象
weixin_64603510的博客
08-09 1509
C++类与对象
C++:类和对象思维导图
03-29
这是关于C++类和对象特性的思维导图，更加详细的解释请查看我的个人博客
C++类和对象
06-01
C++中类与对象的概念，原理，使用规则，常用语法
【C++】智能指针的使用及其原理
weixin_58252863的博客
12-21 764
本文系统介绍了C++智能指针的使用与实现原理。首先通过内存泄漏案例展示了智能指针的必要性，分析了RAII设计思想在资源管理中的应用。详细讲解了标准库中的智能指针：auto_ptr（已废弃）、unique_ptr（独占所有权）、shared_ptr（共享所有权）和weak_ptr（解决循环引用）。文章重点剖析了shared_ptr的引用计数机制及其线程安全问题，并演示了如何通过weak_ptr解决循环引用导致的内存泄漏。最后介绍了智能指针的历史渊源（与Boost库的关系）以及内存泄漏的检测与防范方法。通过自定
c++之基础A（二维数组）第四课
2302_76761070的博客
12-21 278
本文介绍了二维数组在C++游戏开发中的基本应用，特别是迷宫类游戏的实现。通过示例代码演示了二维数组的输入输出操作，以及如何计算每行和每列的和。输入输出采用双重循环结构，行列求和则分别通过固定行或列索引来实现。这些基础操作为游戏开发中处理地图数据等场景提供了实用方法，适合编程新手学习二维数组的基本使用技巧。
面试记录12 软件（c++）工程师
weixin_44389243的博客
12-23 482
科莱瑞迪
C++ 类与对象：解锁面向对象编程的核心密码（中）
emtai486的博客
12-20 1095
默认成员函数：构造，析构，拷贝构造，赋值重载，取地址重载
Linux C/C++ 学习日记（57）：定时器
2302_79943247的博客
12-21 616
本文介绍了定时器的实现原理与代码示例。定时器是管理大量延时任务的模块，通过高效的数据结构（如红黑树、最小堆）组织任务，并使用IO多路复用（如epoll_wait）触发机制。文中采用红黑树存储定时任务，利用steady_clock确保时间单调性，通过emplace_hint优化插入效率。代码实现了添加/删除定时任务、检测触发和执行回调等功能，最终演示了结合epoll处理定时任务的完整流程。该方案兼顾了IO事件和定时任务处理，避免了sleep等低效方法。
c++ 语言教程——17面向对象设计模式（六）
最新发布
mwl0223的博客
12-25 231
本文介绍了三种行为型设计模式：访问者模式、中介者模式和解释器模式。访问者模式通过分离数据结构与操作，支持在不修改元素类的情况下添加新操作，适用于操作频繁变化的场景，但会破坏封装性。中介者模式通过引入中介对象来协调多个对象间的交互，降低耦合度，适用于需要集中管理复杂交互的系统。文章通过C++代码示例分别展示了访问者模式在商品计价场景的应用，以及中介者模式在聊天室系统中的实现，分析了各自的优缺点和适用场景。
C++类和对象习题精讲与答案解析
1. **类的定义**：在C++中定义类的基本语法包括关键字`class`，后跟类名和类体。类体由花括号包围，内含数据成员和成员函数的声明。例如： ```cpp class MyClass { private: int privateVar; // 私有成员变量 ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值