类与对象【中】

最新推荐文章于 2024-09-26 21:10:57 发布
最新推荐文章于 2024-09-26 21:10:57 发布
阅读量1k 收藏 28
点赞数 16
文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wujianghh/article/details/141087865
版权

1.类的六个默认构造函数

如果一个类中什么成员都没有简称空类
但空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显示实现，编译器会生成的成员函数。
在这里插入图片描述

2.构造函数

2.1 概念

下面是构造函数的几种形式

class Date
{
public:
	Date()   //无参构造函数
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	Date(int year,int month,int day)   //带参数构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(int year=1, int month=1, int day=1)   //全缺省的构造函数
	//可以与无参数的构造函数同时存在，但是不可以与带参数的构造函数同时存在
	//但是一般也不会让两个构造函数同时存在，不然在main函数中使用可能会有歧义
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:   
	int _year;
	int _month;
	int _day;
int main()
}
	/*Date d1();*/    //不可以这样写，因为这样也可能为函数声明
	Date d1;   //用的无参的那个构造函数
	d1.print();
	Date d2(2024, 1, 27);
	d2.print();
	return 0;
}
};

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

private:   
	int _year=1;
	int _month=1;
	int _day=1;

如果这里给了缺省值，那么默认生成的构造函数会用缺省的数完成初始化。-

2.2 特性

构造函数是特殊的成员函数，需要注意的是构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
1.函数名与类名相同
2.无返回值
3.对象实例化时编译器自动调节对应构造函数
4.构造函数可以重载
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;
 }

6.关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？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
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

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

3.析构函数

首先说明一点构造函数只是初始化不是创建析构函数也不是销毁，只是清理资源，也相当于之前说的链表中的Destroy

3.1 概念

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

3.2 特性

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

3.3

3.3.1为什么要使用析构函数

int main()
{
func();
date d1;
d1.print();
stack stl;
return 0;
}

假如main函数结束了，main函数开辟的空间也就会自动销毁了，但stl这个指针还指向这个空间，这个空间在堆上开辟的，当main函数结束以后堆上的空间并没有被释放，造成内存泄露。在之前链表，二叉树这些里面使用Destroy来清理这种动态开辟的资源。所以也要用析构函数对这里进行清理。

3.3.2 析构函数清理的顺序

class Date
{
public:
	Date(int year=1)
	{
		_year = year;
	}
	~Date()
	{
		cout << "~Date()->" << _year << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1);
	Date d2(2);

	return 0;
}

在这里插入图片描述
从这里就可以看出来析构函数是后进先出，即后创建的先处理。

int main()
{
	Date d1(1);
	Date d2(2);
	static Date d3(3);
	return 0;
}

在这里插入图片描述

这里d3是静态的为全局变量，所以最后清理

class Date
{
public:
	Date(int year=1)
	{
		_year = year;
	}
	~Date()
	{
		cout << "~Date()->" << _year << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
void func()
{
	Date d3(3);
	static Date d4(4);
}
int main()
{
	Date d1(1);
	Date d2(2);
	func();
	return 0;
}

在这里插入图片描述
这里先销毁func函数，再销毁main函数，再销毁全局变量

class Date
{
public:
	Date(int year=1)
	{
		_year = year;
	}
	~Date()
	{
		cout << "~Date()->" << _year << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
void func()
{
	Date d3(3);
	static Date d4(4);
}
Date d5(5);
int main()
{
	Date d1(1);
	Date d2(2);
	func();
	return 0;
}

在这里插入图片描述
先局部对象（后定义先析构），再局部静态，再全局对象（后定义先析构）
不管是局部还是全局都是后定义先清理（注意：局部与局部比，全局与全局比）

4.拷贝构造函数

4.1概念

在创建对象的时候，可否创建一个与已存在对象一模一样的对象呢？
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰）在用已存在的类类型对象创建新对象时由编译器自动调用。

4.2 特征

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

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

	}
	Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void func1(Date d)      //传值传参
{
}
void func2(Date& rd)   //传引用传参
{
}

int main()
{
	Date d1(2024.1,28);
	func1(d1);
	func2(d1);
	return 0;
}

在这里插入图片描述
这里的1至4代表的是func1(d1)；执行的顺序。
传值调用先要进行传参，而传参时先要进行拷贝构造，所以这里就是一个无限的循环，不会停止。

在这里插入图片描述
这里是引用传参，无需再使用拷贝构造了。

下面再举一个例子来说明为什么拷贝函数可能造成无限的循环


class Date
{
public:
	Date(int year=1,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;
	}
private:
	int _year;
	int _month;
	int _day;
};

}

int main()
{
	Date d1(2024.1,28);
	Date d2(d1);    //这里会出现大问题
	return 0;
}

在这里插入图片描述

这里是传参调用要用拷贝构造，而由于拷贝构造函数也是传值调用，它会再调用拷贝构造，会一直这样无限递归，连函数都进不去。
而这里只有引用才可以解决无限递归调用。

下面是完整的拷贝构造

class Date
{
public:
	Date(int year=1,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;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2024.1,28);
	Date d2(d1);
	d1. print();
	d2. print();

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

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

  1. 拷贝构造函数典型调用场景：
    使用已存在对象创建新对象
    函数参数类型为类类型对象
    函数返回值类型为类类型对象
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.赋值运算符重载

5.1 运算符重载

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

下面是使用运算符重载的一个例子：

// 全局的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;
};

5.2 赋值运算符重载

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

2.赋值运算符只可以重载成类的成员函数不能重载成全局函数：原因是，赋值运算符如果不显示实现，编译器会生成一个默认的。因此用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
3.用户没有显示实现时，编译器会默认生成一个赋值运算符重载，以值的方式逐字拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

class Date
{
public:
	Date(int year=1,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;
	}

	bool operator==(const Date& y)
	{
		return _year == y._year
			&& _month == y._month
			&& _day == y._day;
	
	}
	bool operator<(const Date& y)
	{
		if (_year < y._year)
		{
			return true;
		}
		else if (_year==y._year)
		{
			if (_month < y._month)
			{
				return true;
			}
			else if (_month == y._month)
			{
				return _day < y._day;
			}
		}
		return false;
	}
	bool operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2024,1,28);
	Date d2(2024,4,6);

	cout << d1.operator==(d2) << endl;
	cout << d1.operator<(d2) << endl;
	//由于定义的函数在类里面，所以这样写传的d1的时候由隐藏的this指针负责
	//上面这两句代码与下面的这两句代码是等价的
	cout << (d1 == d2) << endl;
	cout << (d1<d2) << endl;
	
	Date d3(d1);  //拷贝构造，同类型一个存在的对象进行初始化要创建的对象
	d2 = d1;        //赋值重载  已经存在的对象，一个拷贝赋值给另一个

	d1 = d2 = d3;   //这句代码是错误的，自定义类型是不可以连续赋值的，除非像下面这样加上返回值
	return 0;


//如果要可以进行连续赋值的话，加上返回值就可以
Date operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
}
//其实改成这样还是有缺陷，这里用的是传值返回，返回的并不是*this，而是它的拷贝，同类型拷贝又要调用拷贝构造，这样太浪费了，因此可以改成下面的样子


Date& operator=(const Date& d)  //加一个引用
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}

5.3 前置++和后置++重载

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // 前置++：返回+1之后的结果
 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
 Date& operator++()
 {
 _day += 1;
 return *this;
 }
 // 后置++：
 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
 // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
一份，然后给this+1
 //       而temp是临时对象，因此只能以值的方式返回，不能返回引用
 Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }
private:
 int _year;
 int _month;
 int _day;
};
南子北游
关注
java类与对象
12-21
java类与对象 类与对象的概念类的定义格式对象的创建和使用对象的创建对象访问类的变量与方法成员变量默认值成员变量的封装步骤# 封装中this关键字的使用成员方法的重载overload重载的意义重载的格式构造方法构造...
二_类与对象_
10-03
在编程世界中，类与对象是面向对象编程（OOP）的核心概念。面向对象编程是一种设计和实现软件的方法，它基于“对象”的概念，而这些对象则是类的实例。类可以看作是创建对象的蓝图，它定义了对象的数据属性和行为。...
第十章 类与对象
01-07
本章详细介绍了 C++ 中面向对象编程的核心概念——类与对象。通过定义类来组织和管理代码，不仅可以提高程序的可读性和可维护性，还能更好地模拟现实世界中的复杂系统。掌握了类与对象的基本原理后，开发者可以更...
简单了解JAVA中类、实例与Class对象
08-25
加载完成后，JVM会为这个类创建一个Class对象，这个对象是类的唯一实例，在Java中这个Class对象是唯一的，并且与类的每个实例共享。 这个Class对象可以看作是类的“模板”，JVM通过这个模板来理解类的结构和行为。...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1156
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 961
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 850
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
最新发布
scy2429828663的博客
09-26 232
【代码】求n的阶乘的相反数（c语言）
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 651
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 658
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
C#测试调用Ghostscript.NET浏览PDF文件
gc_2299的博客
09-23 425
学习并测试调用Ghostscript.NET模块打开及浏览PDF文件的基本用法
简易STL实现 | Set 的实现
AsherGu的博客
09-26 267
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
Python对于C语言使用者来说的反直觉特性
m0_62710548的博客
09-22 715
在编程领域，从一种语言转向另一种语言总是伴随着一系列的学习和调整。对于习惯了C语言严谨性的程序员来说，转向Python可能会遇到一些令人惊讶的特性。以下是我在短暂学习了一段时间python后察觉到的一些python的特性。
C++-Primer-Plus：18 个重点笔记
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 777
虽然从理论上讲，前缀递增/递减操作符由于不需要保存操作前的值而可能更高效，但这种差异在现代C++编程实践中往往被编译器的优化所掩盖。因此，在选择使用前缀还是后缀操作符时，更应该关注的是代码的清晰性和可读性，而不是微小的效率差异。在大多数情况下，遵循团队的编码规范或个人的编码习惯即可。最后，对于C++ Primer这样的经典书籍来说，它可能更多地是从语言规范和实现原理的角度来讨论这个问题，而不是从实际应用中的性能差异出发。
C++ 解析 RDP 协议
道亦无名
09-22 359
远程桌面协议（Remote Desktop Protocol, RDP）是微软开发的一种网络通信协议，用于提供远程桌面会话服务。它允许用户通过网络连接至远程计算机，并像使用本地计算机一样操作远程系统。本文档将详细探讨在C++环境中如何解析RDP协议，涵盖协议层次解析、连接过程管理、数据加密解密、功能数据处理、错误与异常处理以及协议版本适配等方面。
第一章：开始学习C语言-1介绍C语言
pingguocu3的博客
09-23 932
这篇文章将帮你了解C语言，它的历史，主要特点和应用。C语言是1970年发明的一种通用的过程式编程语言。C语言适用于操作系统、数据库系统、图形软件等系统编程。游戏引擎。最后编辑于：2024-09-22 09:32:39©著作权归作者所有,转载或内容合作请联系作者。
C++之模版的进阶
2301_81857941的博客
09-22 919
一个程序由若干个源文件共同实现，而每一个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。【优点】1.增强了代码的灵活性2.模版复用了代码，节省资源【缺陷】1.模版会导致代码膨胀问题2.出现模版错误时，错误原因难以定位。
C++—vector的常见接口与用法（正式进入STL）
GGbond665的博客
09-21 405
vector的常见接口与用法
C++入门：类与对象基础习题详解
C++ 类与对象是面向对象编程（Object-Oriented Programming, OOP）的基础概念，本文档主要针对初学者提供了一系列关于C++ 中类与对象的习题和解答。首先，我们来看填空题部分： 1. 在C++ 中，引入类定义的关键字是`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

南子北游

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

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

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

打赏作者

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

抵扣说明：

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

余额充值