C++[异常与IO]

已于 2023-03-24 16:56:29 修改
阅读量121 收藏
点赞数 1
分类专栏： 临时分类 文章标签： 程序人生 windows visual studio 开发语言 c++
于 2023-03-21 22:28:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43281363/article/details/129619072
版权 
2023-3-17首次编辑

C++[异常与IO]

Unit 10:异常

一.概念

  • 异常处理就是处理程序中的错误
  • 错误是指在程序运行的过程中发生的一些异常事件

二.作用

解决C语言处理异常的方法缺陷:

  1. 返回值意思不明确
  2. 返回值只能返回一条信息
  3. 返回值可以忽略

三.基本语法与执行流程

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

int func(int a, int b)
{
	if (b==0)
	{
		//第二步:抛出异常
		throw 10; //抛出一个int类型的异常
		cout << "throw后的代码" << endl;
	}
}

void test()
{
	int a = 10;
	int b = 0;

	//第一步:把有可能出现异常的代码块放到try中
	try
	{
		func(a, b);
		cout << "func后的代码" << endl;
	}
	//第三步:接受一个int类型的异常
	catch (int)
	{
		cout << "接收到一个int类型的异常" << endl;
	}
}

int main()
{
	test();
	system("pause");
	return 0;
}

四.异常的优势

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

class Maker
{
public:
	void printMaker()
	{
		cout << "除数不能为0" << endl;
	}
};

int func(int a, int b)
{
	if (b == 0)
	{
		//Maker m;
		//throw m; //抛出一个Maker类型的异常
		throw 20.22; //抛出一个double类型的异常
	}
	return a / b;
}

void test()
{
	int a = 10;
	int b = 0;
	try
	{
		func(a, b);
	}
	catch (int)
	{
		cout << "接收到一个int类型的异常" << endl;
	}
	catch (Maker maker)
	{
		cout << "接收到一个Maker类型的异常" << endl;
		maker.printMaker();
	}
	catch (double)
	{
		//如果不想处理异常,可以往上抛出,抛给调用本函数的函数
		throw;
	}
}

int main()
{
	try
	{
		test();
	}
	catch (double)
	{
		cout << "接收一个double类型的异常" << endl;
	}
	system("pause");
	return 0;
}
  • 用户可以忽略返回值,但不能忽略异常,如果忽略将会报错
  • 返回值只能返回一条信息,但对象有成员函数,可以包含多个信息
  • 可以逐层依赖处理异常

五.异常的严格类型匹配

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

class Maker
{
public:
	
};

int func(int a, int b)
{
	if (b == 0)
	{
		//Maker m;
		//throw m; //抛出一个Maker类型的异常
		//throw 20.22; //抛出一个double类型的异常
		//throw 'c'; //抛出一个char类型的异常
		throw 20.0f; //抛出一个float类型的异常
	}
}

void test()
{
	int a = 10;
	int b = 0;
	try
	{
		func(a, b);
	}
	catch (Maker)
	{
		cout << "接受一个Maker类型的异常" << endl;
	}
	catch (double)
	{
		cout << "接受一个double类型的异常" << endl;
	}
	catch (char)
	{
		cout << "接受一个char类型的异常" << endl;
	}
	catch (...) //接受其他类型的异常
	{
		cout << "接受一个其他类型的异常" << endl;
	}
}

int main()
{
	test();
	system("pause");
	return 0;
}

六.异常的接口声明

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

void func() throw(int, char) //只允许抛出int或者char异常
{
	throw 10; //抛出一个double类型的异常,Qt上程序会阻挡
}

int main()
{
	try
	{
		func();
	}
	catch (int)
	{
		cout << "int" << endl;
	}
	catch (...)
	{
		cout << "..." << endl;
	}
	system("pause");
	return 0;
}

七.栈解旋

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

class Maker
{
public:
	Maker()
	{
		cout << "Maker的构造" << endl;
	}
	Maker(const Maker &m)
	{
		cout << "Maker的拷贝构造" << endl;
	}
	~Maker()
	{
		cout << "Maker的析构" << endl;
	}
};

void func()
{
	//栈解旋:
	//在抛出异常的函数中,如果抛出异常之后,但函数没有结束,此时栈上申请的对象都会被释放
	Maker m;
	throw m; //这个m是Maker m拷贝的一份
	cout << "func函数结束" << endl;
}

void test()
{
	try
	{
		func();
		cout << "func代码后" << endl;
	}
	catch (Maker)
	{
		cout << "接收一个Maker类型的异常" << endl;
	}
}

int main()
{
	test();
	system("pause");
	return 0;
}

八.异常变量的生命周期

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

class Maker
{
public:
	Maker()
	{
		cout << "Maker的构造" << endl;
	}
	Maker(const Maker &m)
	{
		cout << "Maker的拷贝构造" << endl;
	}
	~Maker()
	{
		cout << "Maker的析构" << endl;
	}
};

//产生三个对象
void func1()
{
	Maker m; //第一个对象,在异常接收前被释放
	throw m; //第二个对象,是第一个对象拷贝过来的
}

void test1()
{
	try
	{
		func1();
	}
	catch (Maker m1) //第三个对象,是第二个对象拷贝过来的
	{
		cout << "接收一个Maker类型的异常" << endl;
		//第二个对象和第三个对象在catch结束时释放
	}
}

//产生两个对象
void func2()
{
	throw Maker(); //第一个对象,匿名对象
}

void test2()
{
	try
	{
		func2();
	}
	catch (Maker m1) //第二个对象,是第一个对象拷贝过来的
	{
		cout << "接收一个Maker类型的异常" << endl;
		//第一个对象和第二个对象在catch结束时释放
	}
}

//产生一个对象(常用)
void func3()
{
	throw Maker(); //匿名对象
}

void test3()
{
	try 
	{
		func3();
	}
	catch (Maker &m1) //引用匿名对象
	{
		cout << "接收一个Maker类型的异常" << endl;
	}
}

//注意:
void func4()
{
	//编译器不允许对栈中的匿名对象取地址操作
	//throw Maker(); //err

	//编译器允许对堆区中的匿名对象取地址操作
	throw new Maker();
}

void test4()
{
	try
	{
		func4();
	}
	catch (Maker* m1) //对匿名对象取地址
	{
		cout << "接收一个Maker类型的异常" << endl;
		delete m1;
	}
}

int main()
{
	test1();
	test2();
	test3();
	test4();
	system("pause");
	return 0;
}

九.异常的多态

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//异常的基类
class Father
{
public:
	virtual void printM()
	{

	}
};

//1.有继承
class SonNULL :public Father
{
public:
	virtual void printM() //2.重写父类的虚函数
	{
		cout << "空指针异常" << endl;
	}
};

class SonOut :public Father
{
public:
	virtual void printM()
	{
		cout << "越位溢出" << endl;
	}
};

void func(int a, int b)
{
	if (a==0)
	{
		throw SonNULL();
	}
	if (b==0)
	{
		throw SonOut();
	}
}

void test()
{
	int a = 0;
	int b = 10;
	try
	{
		func(a, b);
	}
	catch (Father &f) //3.父类引用指向子类对象
	{
		f.printM();
	}
}

int main()
{
	test();
	system("pause");
	return 0;
}

十.系统提供的标准异常

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
#include <string>
#include <stdexcept> //标准异常库(Vs2013可以不需要写)
using namespace std;

//1.系统的标准异常类
class Maker1
{
public:
	Maker1(int age)
	{
		if (age<0||age>150)
		{
			throw out_of_range("系统的标准异常类:年龄不在范围内");
		}
		else
		{
			this->age = age;
		}
	}
public:
	int age;
};

void test1()
{
	try
	{
		Maker1 m(200);
	}
	catch (out_of_range &ex)
	{
		cout << ex.what() << endl;
	}
}

//2.自己编写的异常类
class MyOut_of :public exception
{
public:
	MyOut_of(const char* errorinfo)
	{
		//const char*转换string
		this->m_Info = string(errorinfo);
	}
	MyOut_of(const string errorinfo)
	{
		this->m_Info = errorinfo;
	}
	const char* what() const
	{
		//把string转换成const char*
		return this->m_Info.c_str();
	}
public:
	string m_Info;
};

class Maker2
{
public:
	Maker2(int age)
	{
		if (age<0 || age>150)
		{
			throw MyOut_of("自己编写的异常类:年龄不在范围内");
		}
		else
		{
			this->age = age;
		}
	}
public:
	int age;
};

void test2()
{
	try
	{
		Maker2(200);
	}
	catch (MyOut_of &ex)
	{
		cout << ex.what() << endl;
	}
}

int main()
{
	test1();
	test2();
	system("pause");
	return 0;
}

Unit 11:IO

流的概念和流泪库的结构

  • 标准IO:对系统的标准输入输出设备进行读写
  • 文件IO:对磁盘进行输入输出读写
  • 串IO:对内存进行读写

一.系统标准的输入流

成员函数:

  • cin.get() //一次只能读取一个字符
  • cin.get(一个参数) //读取一个字符
  • cin.get(两个参数) //可以读取字符串
  • cin.getline() //取一行,换行符丢弃
  • cin.ignore() //忽略
  • cin.peek() //偷窥
  • cin.putback() //放回
#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//单个输入
void test1()
{
	//输入ab
	char c = cin.get(); //读取a
	cout << c << endl;
	c = cin.get(); //读取b
	cout << c << endl;
	c = cin.get(); //读取换行符
	cout << c << endl;

	//其他形式
	cin.get(c); //阻塞
	cout << c << endl;
	cin.get(c); //读取换行符
	cout << c << endl;

	char ch1, ch2, ch3, ch4;
	cin.get(ch1).get(ch2).get(ch3).get(ch4);
	cout << ch1 << ch2 << ch3 << ch4 << endl;
}

//按行输入
void test2()
{
	char buf[1024] = { 0 };
	cin.get(buf, 1024); //读取缓冲区时,换行符不拿走
	char c = cin.get();
	if (c=='\n')
	{
		cout << "换行符还在缓冲区中" << endl;
	}
	cout << buf << endl;

	cin.getline(buf, 1024); //读取缓冲区时,换行符丢弃
	char ch = cin.get(); //阻塞
	if (ch == '/n')
	{
		cout << "换行符还在缓冲区中" << endl;
	}
	cout << buf << endl;
}

//忽略(参数为N,表示忽略N个字符)
void test3()
{
	输入ab
	//cin.ignore(); //默认忽略缓冲区内第一个字符
	//char c = cin.get(); //b
	//cout << c << endl;

	//输入abcde
	cin.ignore(3); //忽略缓冲区内前三个字符
	char ch = cin.get(); //d
	cout << ch<< endl;
}

//偷窥(只看不拿)
void test4()
{
	//输入a
	char c = cin.peek(); //偷窥第一个字符a
	cout << "c:" << c << endl;

	char ch = cin.get(); //拿走a
	cout << "ch:" << ch << endl;
}

//返回(拿走后,放回去)
void test5()
{
	//输入a
	char c = cin.get(); //拿走a
	cout << c << endl;
	cin.putback(c); //放回a

	char buf[1024] = { 0 };
	cin.getline(buf, 1024); //拿走放回的a
	cout << buf << endl;
}

//综合案例一:判断用户输入的是字符串还是数字
void test6()
{
	cout << "请输入一个字符串或数字:" << endl;
	char c = cin.peek();
	if (c >= '0' && c <= '9')
	{
		int num;
		cin >> num;
		cout << "输入的数字是:" << num << endl;
	}
	else
	{
		char buf[1024] = { 0 };
		cin >> buf;
		cout << "输入的字符串是:" << buf << endl;
	}
}

//综合案例二:输入0~10的数字,直到输入正确为止
void test7()
{
	int num;
	while (1)
	{
		cin >> num;
		if (num >= 0 && num <= 10)
		{
			cout << "输入正确!!!" << endl;
			break;
		}
		cout << "重新输入:" << endl;

		//重置标志位
		cin.clear();
		
		//拿走缓冲区内容
		char buf[1024] = { 0 };
		cin.getline(buf, 1024);

		//打印标志位
		//0表示正常,无数据
		//1表示不正常,有数据
		cout << cin.fail() << endl;
	}
}

int main()
{
	//test1();
	//test2();
	//test3();
	//test4();
	//test5();
	//test6();
	test7();
	system("pause");
	return 0;
}

二.系统标准的输出流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//单个输出
void test1()
{
	cout.put('c');

	//链式编程
	cout.put('a').put('b').put('c');
}

//按行输出
void test2()
{
	char buf[] = "Hello World";
	cout.write(buf, strlen(buf));
}

//通过流成员函数实现格式化的输出
void test3()
{
	int num = 99;

	//设置宽度
	cout.width(20);

	//填充
	cout.fill('*');

	//让数据在左边
	cout.setf(ios::left);

	//卸载十进制
	cout.unsetf(ios::dec);

	//安装十六进制
	cout.setf(ios::hex);

	//显示基数
	cout.setf(ios::showbase);

	//卸载十六进制
	cout.unsetf(ios::hex);

	//安装八进制
	cout.setf(ios::oct);

	cout << num << endl;
}

//通过控制符格式化输出(引入头文件iomanip)
#include <iomanip>

void test4()
{
	int num = 99;

	//设置宽度
	cout << setw(20);

	//填充
	cout << setfill('~');

	//显示基数
	cout << setiosflags(ios::showbase);

	//让数据在左边
	cout << setiosflags(ios::left);

	//十六进制
	cout << hex;

	//八进制
	cout << oct;

	//十进制
	cout << dec;

	cout << num << endl;
}

//打印浮点数后面的小数点
void test5()
{
	double d = 20.22;

	//设置显示浮点数
	cout << setiosflags(ios::fixed);

	//显示小数点后10位
	cout << setprecision(10) << endl;

	cout << d << endl;
}

int main()
{
	//test1();
	//test2();
	//test3();
	//test4();
	test5();
	system("pause");
	return 0;
}

三.文件读写操作

在这里插入图片描述

C++文件读写：

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//1.引入头文件
#include <fstream>

//把程序中的信息输出到缓冲区,然后写到文件(写文件)
void test1()
{
	//2.定义流对象
	ofstream ofs;

	//3.打开文件,以写的方式打开(如果没有文件,就创建)
	ofs.open("test.txt", ios::out | ios::trunc);

	//4.判断是否打开成功
	if (!ofs.is_open())
	{
		cout << "打开文件" << endl;
	}

	//5.写信息
	ofs << "姓名:悟空" << endl;
	ofs << "年龄:18" << endl;
	ofs << "身高:180cm" << endl;

	//6.关闭文件
	ofs.close(); //关闭文件,并刷新缓冲区
}

//把磁盘信息输入到缓冲区,然后读到程序中(读文件)
void test2()
{
	ifstream ifs;
	ifs.open("test.txt", ios::in);
	if (ifs.is_open()==false)
	{
		cout << "打开失败" << endl;
	}

	//第一种方式读取文件
	//一行一行读取
	/*char buf[1024] = { 0 };
	while (ifs >> buf)
	{
		cout << buf << endl;
	}*/

	//第二种方式读文件
	/*char buf[1024] = { 0 };
	while (!ifs.eof()) //判断是否读到文件尾部
	{
		ifs.getline(buf, sizeof(buf));
		cout << buf << endl;
	}*/

	//第三种方式读取文件
	//单个字符读取
	char c;
	while ((c=ifs.get())!=EOF)
	{
		cout << c;
	}

	ifs.close();
}

int main()
{
	//test1();
	test2();
	system("pause");
	return 0;
}

四.二进制文件读写

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
#include <fstream>
using namespace std;

class Maker
{
public:
	Maker()
	{

	}
	Maker(const char* name, int age)
	{
		this->age = age;
		strcpy(this->name, name);
	}
public:
	char name[64];
	int age;
};

//写文件
void test1()
{
	Maker m1("悟空", 18);
	Maker m2("贝吉塔", 22);

	ofstream ofs;
	ofs.open("test.txt", ios::out | ios::trunc | ios::binary);
	if (!ofs.is_open())
	{
		cout << "打开失败" << endl;
	}

	//写
	ofs.write((const char *)&m1, sizeof(Maker));
	ofs.write((const char *)&m2, sizeof(Maker));

	ofs.close();
}

//读文件
void test2()
{
	ifstream ifs;
	ifs.open("test.txt", ios::in | ios::binary);
	if (!ifs.is_open())
	{
		cout << "打开失败" << endl;
	}

	//读
	Maker m1;
	Maker m2;

	ifs.read((char*)&m1, sizeof(Maker));
	ifs.read((char*)&m2, sizeof(Maker));

	cout << "Name:" << m1.name << " Age:" << m1.age << endl;
	cout << "Name:" << m2.name << " Age:" << m2.age << endl;

	ifs.close();
}

//注意:当文件读写时,类中的成员变量不要有string类型
class Maker2
{
public:
	Maker2()
	{

	}
	Maker2(string name, int age)
	{
		this->name = name;
		this->age = age;
	}
public:
	string name;
	//string类中有一个成员指针char*,该指针指向存储字符串的空间
	//当我们把string类的数据存储到文件中，再读出来时，不能保证指针有效
	//string 开辟的空间如果大于16个字节就在堆区，小于就在栈区
	int age;
};

int main()
{
	test1();
	test2();
	system("pause");
	return 0;
}
Cforikl_
关注
专栏目录
C++笔记（六）——I/O&异常
weixin_43279709的博客
03-09 351
iostream 标准库提供了 cin 和 cout 方法分别用于从标准输入读取流和向标准输出写入流。 ·标准库 fstream定义了三个新的数据类型用于文件的访问。 ·open() 函数是 fstream、ifstream 和 ofstream 对象的一个成员。open() 成员函数的第一参数指定要打开的文件的名称和位置，第二个参数定义文件被打开的模式。可以把以上两种或两种以上的模式结合使用...
异常与IO
qq_59421980的博客
08-08 608
异常1、什么是异常？ 程序没有按预期运行就叫异常。 2、为什么要学习异常？ 为了更好的解决异常情况。3、异常分类 throwable Error：错误，指的是无法被处理的异常，也不需要程序员去处理该类问题。 OutOfMemoryError StackOverflowError Exception：异常 编译时异常（受检查异常checkedException）：编译期间就需要处理的异常，不处理编译
C++基础—类型转换 IO 异常处理
u011536013的博客
05-25 242
1.类型转换 C++提供了4种类型转换操作符应对不同场合的应用 const_cast :去const属性（const相当于Java中的final） static_cast : 静态类型转换，如 int 转 char dymamic_cast : 动态类型转换， 如 子类和父类之间的多态类型转换 reinterpret_cast : 仅重写解释类型， 没有...
C++的异常与IO
u013172018的专栏
07-05 791
为什么要有异常------why? 1.通过返回值表达错误.     malloc, fcntl      局部对象都能得到正确析构；     层层判断返回值，流程繁琐； 2.setjmp, longjmp,远程跳转    例如：     jump_buf g_env;     if(setjmp(g_env) == -1)     {         错误处理
C++ I/O操作与I/O异常
qq_39191122的博客
11-11 713
C++ I/O操作 C++ I/O异常
C++的IO库常见错误
ylh1234的博客
07-04 397
1.写入文件地址如D:\\try.txt,那么在D盘中文件名应该为try,无需添加txt防止内存读取过程中出现错误，一般在VS2013及其以上版本不会出错，VS2008会读取错误. 2.将文件读取进入vector中，如果使用了push_back(s)则容易使得定义的迭代器失效。
C++异常
小白的逆袭
07-18 318
程序的错误大致可以分为三种，分别是语法错误、逻辑错误和运行时错误： 语法错误在编译和链接阶段就能发现，只有 100% 符合语法规则的代码才能生成可执行程序。语法错误是最容易发现、最容易定位、最容易排除的错误，程序员最不需要担心的就是这种错误。 逻辑错误是说我们编写的代码思路有问题，不能够达到最终的目标，这种错误可以通过调试来解决。 运行时错误是指程序在运行期间发生的错误，例如除数为 0、内存...
c++写的io操作操作
03-21
在C++编程中，I/O（输入/输出）操作是程序与外部世界交互的重要部分，包括从磁盘、键盘、屏幕等设备读取数据以及向这些设备写入数据。C++提供了多种方式进行I/O操作，主要包括标准库中的`iostream`、`fstream`和`...
C++标准IO文档
02-22
### C++标准IO知识点详解 #### 一、C++标准IO概述 C++标准库提供了丰富的输入输出（IO）功能，这些功能通过一系列面向对象的API实现，支持对各种设备如控制台、文件等的读写操作。这些API还包括一些特殊类型，允许...
IO读写操作c++IO读写操作c++
12-29
在C++编程中，IO（Input/Output）读写操作是程序与外部世界交互的关键环节。无论是处理用户输入，还是保存或加载数据，都离不开IO操作。本篇将深入探讨C++中的IO读写，特别是关于基础类型以二进制方式的读写。 在...
实例005——使用C++实现格式化数据的IO.zip
01-14
在C++编程中，输入/输出（Input/Output, IO）是程序与外部世界交互的基础。格式化数据的IO指的是按照特定格式读取或写入数据，如控制浮点数的小数位数、添加分隔符等。这个实例005——使用C++实现格式化数据的IO.zip...
Windows 结构化异常与 C / C++异常的一些事
vincentccnt的专栏
01-20 2983
一直以来对“异常”以及相关的知识很模糊，这次做个整理，回答几个基本问题以帮助对“异常”的理解： C语言的异常C语言版的try/catch: setjmp, longjmp C++的异常(try/catch)Windows 结构化异常，以及与C++标准异常的联系（__try/__except与try/catch）在Windows API 与标准C++代码混用的项目中，如何较好的捕捉所有异常？
我们都忽略了C++IO流，异常，模板的一些常用方法
qq_45893999的博客
06-05 560
文章目录文件操作异常模板函数模板的基本用法函数模板与普通函数的区别模板的局限性及解决 文件操作 C++的文件操作和C语言的大体上还是一样的，C++是用的对象，C语言是直接用的函数，操作是和C语言学的一样 C++的文件操作是用得 fstream 类型对象来操作，需要打开头文件fstream fstream file；//文件对象，就是通过这个对象来实现文件的操作 file.open("文件路径",打开方式|打开方式|打开方式~~~);//如果需要用多个打开方式就多项两个中间用 | 隔开 file.
C++ IO流 异常处理
weixin_44916364的博客
08-24 697
一、虚函数表 什么是虚函数表，在C++的类中，一旦成员函数中有虚函数，这个类中就会多一个虚函数表指针，这个指针指向一个虚函数表，表中记录了这个类中所有的虚函数，当这个类被继承，它的子类中也会有一个虚函数表（不管子类中有没有虚函数），如果子类的成员函数中有函数签名与父类的虚函数一样的就会用子类中的函数替换它在虚函数中的位置，这样就达到了覆盖的效果 当通过类指针或引用调用函数时，会根据对象中实际的虚...
C/C++ IO操作，输出错误信息
renguangmeng的博客
08-16 3025
#include&lt;stdio.h&gt; #include&lt;errno.h&gt; //函数名：show_err //功能：在_DEBUG模式下显示IO系统错误信息 //参数： 类型char* ，str 要显示的错误消息 //返回值：类型int 错误码 int show_err(char *str) { int err_num = errno; #if (_DEBUG) { ...
C++ 异常 exception throw
绝知此事要躬行
02-24 6141
之前很少用到C++的exception机制，看到C++ Primer的第6章，简要的介绍一下： 首先，C++ 的异常处理包括： throw表达式。如： #include #include using namespace std; int main() { int x; while(cin >> x) { if (x == 0) { throw runtime_error(
C++字符串IO与编程基础
此外，C++还引入了泛型编程（如模板），异常处理，以及运算符重载等功能，使代码更加灵活和高效。 C++之父Bjarne Stroustrup建议C程序员避免使用宏，而应使用const、enum、inline函数、模板和命名空间等特性。他还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cforikl_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值