C++基础知识

目录

C++的基本使用

C++数据的输入与输出

C++使用命令行

具体案例

C++生成随机数

C++中程序退出的两种方式 

返回值返回

调用exit()函数

关键字

标识符命名规则

数据类型

整形

实型（浮点型）

浮点型变量分为2种

表示小数的两种方式

案例演示

字符型

案例演示

字符串类型

两种风格

两种风格字符串之间的差异

布尔数据类型

bool类型只有两个值

查看数据的类型

具体使用方法

命名空间

前言

访问命名空间的内容

给命名空间起别名

new和delete关键字

new关键字的使用案例

C++的引用

C++中引用案例 

引用的注意事项

引用做函数参数

引用做函数的返回值

前言：

具体案例

引用的本质

常量引用

常量引用原理

经典案例

函数的提高

函数的默认参数

注意：

具体案例

函数的占位参数

具体案例

函数的重载

函数重载满足的条件

函数重载的注意事项

引用作为重载的条件

函数重载碰到函数默认参数

内联函数

前言

具体案例

C++之异常处理机制

异常处理关键字

异常语法

具体案例

自定义异常处理

前言

具体案例

C++的文件操作

前言：

文件类型分为两种

操作文件的三大类

以文本的方式写文件 

写文件操作步骤

文件的打开方式

具体案例

以文本的方式读文件 

读文件操作步骤

具体案例 

读文件的四种方法

方法1

方法2 

方法3

方法4

以二进制的方式对文件进行写操作

具体案例 

二进制方式的读文件

C++的基本使用

C++数据的输入与输出

输入语法：cin >> 变量;

输出语法：cout << 输出内容 << endl;

C++使用命令行

暂停功能：system("pause");

清屏功能：system("cls");

注意：

• 使用命令行功能或输入输出功能时必须要引入头文件#include<iostream>
• 输入和输出语法的cout、endl、cin为对象，它存在于名为std的命名空间当中

具体案例

#include<iostream>
using namespace std;
void main() 
{
	int a = 0;
    //endl为换行
	cout << "请输入a的值：" << endl;
	cin >> a;
	cout << "a的值为：" << a << endl;
    system("cls");
	system("pause");
}

C++生成随机数

#include<iostream>
#include<ctime>
using namespace std;
void main() 
{
	//添加随机数种子（使用当前不断变化的时间生成随机数，防止每次随机数都一样）
	//time()对应库函数#include<ctime>
	srand((unsigned int)time(NULL));
	//rand()代表任意的随机数
	int a = rand();
	//代表100以内的随机数
	int num = a % 100 + 1;
	//对应using namespace std;与#include<iostream>
	cout << num << endl;
	//主要起到一个暂停功能（对应库函数#include <iostream>）
	system("pause");
}

C++中程序退出的两种方式 

返回值返回

#include <iostream>
using namespace std;
void main() {
	while (true) {
		system("pause");
		//退出程序	
		return;
	}
}

调用exit()函数

#include <iostream>
using namespace std;
void main() {
	while (true) {
		system("pause");
		//退出程序	
		exit(0);
	}
}

注意：exit()括号内传的参数相当于程序退出后要返回的代码，传的参数为整形（传入浮点数会返回舍去浮点数的整数）； 

关键字

含义：C++关键字是C++中预先保留的单词

注意：在定义变量或者常量的时候不要使用关键字，否则会产生歧义

标识符命名规则

含义：C++规定给标识符命名时，有一套自己的规则

• 标识符不能是关键字
• 标识符仅能由字母数字下划线组成
• 标识符不能以数字开头
• 标识符中的字母区分大小写

注意：在给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读

数据类型

前言：C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存

整形

作用：整型变量表示的是整数类型的数据

注意：C++中能够表示整数类型有以下几种方式，区别在于所占内存空间不同

实型（浮点型）

作用：用于表示小数

浮点型变量分为2种

• 单精度：float
• 双精度：double

表示小数的两种方式

• 直接用小数点表示：3.14
• 科学计数法表示：314e-2 

案例演示

#include <iostream>
using namespace std;
int main() 
{
	float f = 3.1415926f;
	float f1 = 233e-2;
	cout << "f的值为：" << f << endl;
	cout << "f1的值为：" << f1 << endl;
	double d = 3.1415926;
	cout << "d的值为：" << d << endl;
	//最终结果都为3.14159
	system("pause");
	return 0;
}

注意：

• 若表示一个小数，那么默认的类型为双精度，若表示一个整数，默认的类型为int类型
• 默认情况下，输出一个小数会显示6位有效数字

字符型

作用：字符型变量用于显示单个字符

语法：char ch= 'a';

注意：

• 在显示字符型变量时，用单引号将字符括起来，不要用双引号
• 单引号内只能有一个字符，不能是字符串
• C和C++中字符型变量只占有一个字节
• 字符型变量并不是把字符本身放到内存中储存，而是将对应的ASCII码放入到储存单元

案例演示

#include <iostream>
using namespace std;
int main() 
{
	int a = 98;
	int a1 = 'b';
	char b = 98;
	char b1 = 'b';
	cout << "a的值为：" << a << endl;//98
	cout << "a1的值为：" << a1 << endl;//98
	cout << "b的值为：" << b << endl;//b
	cout << "b1的值为：" << b1 << endl;//b
	system("pause");
	return 0;
}

注意：本质上字符的储存就是将字符对应的ASCII码存到内存中，若以int类型接收得到的就是int类型数据，若以char类型接收，得到的就是char类型数据

字符串类型

作用：用于表示一串字符

两种风格

• C风格字符串：char str[]="hello world";
• C++风格字符串：string str="hello world";（默认使用）

两种风格字符串之间的差异

#include<iostream>
using namespace std;
void main() {
	string str1 = "hello world";
	//成功，string类型可以直接为整个数组赋值
	str1 = "你好，世界";
	//打印：你好世界
	cout << str1 << endl;
	char str2[] = "hi C++";
	//失败，char数组不可以直接为数组赋值
	str2 = "你好，C++";
	//报错
	cout << str2 << endl;
}

结果：

• string类型的字符串可以对整个字符串进行修改，而char数组的字符串不能对整个字符串进行修改，只能对该字符串内的字符进行逐个修改
• 比较char[]类型的字符串若比较两个字符串是否相等则不能用==比较，“==”符号比较的是两个字符串的地址是否相等；但在比较两个string对象时是可以利用“==”的，相等的话，则表达式的返回值为1，不等为0。

布尔数据类型

作用：布尔数据类型代表真或假的值

语法：bool flag=true;

bool类型只有两个值

• true：真（本质上是1，但是非0也代表真）
• false：假（本质上是0）

注意：bool数据类型占1byte的大小

#include <iostream>
using namespace std;
void main() 
{
	bool flag = true;
	cout << "true值为：" << flag << endl;//1
	flag = false;
	cout << "false值为：" << flag << endl;//0
	system("pause");
}

查看数据的类型

关键字：typeid(数据类型/数据).name()

具体使用方法

#include <iostream>
using namespace std;
void main() {
	cout <<"int类型的数据类型为："<<typeid(int).name() << endl;
	cout <<"hello字符串的数据类型为："<<typeid("hello").name() << endl;
}

命名空间

前言

含义：用来组织和重用代码的一个内存单元

关键字：namespace

语法：

namespace 命名空间名{
    代码区
}

注意：

• 命名空间可以嵌套使用，一个命名空间内还可以有另外一个命名空间
• 不可以在函数内定义命名空间
• 若多个命名空间的名称相同，那么他们都属于同一个命名空间

访问命名空间的内容

1.使用作用域符号::进行访问

//创建命名空间
namespace name_1 {
	int num = 1;
	void sayHello() {
		cout << "hello world！" << endl;
	}
}
void main() {
	//使用作用域符号进行访问
	name_1::sayHello();
}

2.通过using关键字指定命名空间后直接访问该命名空间内容

using namespace name_1;
//创建命名空间
namespace name_1 {
	int num = 1;
	void sayHello() {
		cout << "hello world！" << endl;
	}
}
void main() {
	//通过using关键字来使用命名空间的内容
	sayHello();
}

3.通过using关键字指定命名空间的具体内容后访问

using name_1::sayHello;
//创建命名空间
namespace name_1 {
	int num = 1;
	void sayHello() {
		cout << "hello world！" << endl;
	}
}
//主函数
void main() {
	sayHello();
}

给命名空间起别名

语法：namespace 新名=旧名;

//创建命名空间
namespace name_1 {
	int num = 1;
	void sayHello() {
		cout << "hello world！" << endl;
	}
}
//给命名空间起别名
namespace A = name_1;
//主函数
void main() {
	//使用别名访问命名空间的内容
	A::sayHello();
}

new和delete关键字

前言：C++中利用new操作符程序员可以在堆区手动开辟数据空间；程序员也可以手动释放空间，释放空间利用操作符delete

开辟空间语法：new 数据类型[(构造参数)]

返回值：该数据对应类型的指针

释放空间语法：delete 要释放的地址;

开辟数组语法：new 数据类型[数组长度]

返回值：对应开辟出数组空间的首地址（指针）

释放数组空间语法：delete[] 要释放的地址;

new关键字的使用案例

#include <iostream>
using namespace std;
int* func() {
	//在堆区创建空间
	int* p = new int(10);
	return p;
}
void testArr() {
	//在堆中创建长度为10的整形数组
	int* arr = new int[10];
	for (int i = 0; i < 10; i++) {
		//给10个元素赋值
		arr[i] = i + 100;
	}
	for (int i = 0; i < 10; i++) {
		cout << arr[i] << endl;
	}
	//释放数组空间地址
	delete[] arr;
}
void main() {
	testArr();
	int* p = func();
	cout << "a的值为：" << *p << endl;
	cout << "a的值为：" << *p << endl;
	//堆内释放地址
	delete p;
	//内存已经被释放，再次访问就是非法操作
	cout << "a的值为：" << *p << endl;
}

C++的引用

作用：给变量起别名

语法：数据类型 &别名=原名

C++中引用案例 

#include <iostream>
using namespace std;
void main() {
	//引用的基本语法
	int a = 10;
	int &b = a;
	b = 20;
	cout << "a的值为：" << a << endl;//20
	cout << "b的值为：" << b << endl;//20
	system("pause");
}

引用的注意事项

• 引用必须要初始化（必须要告诉引用的是谁，如：int &b;是不正确的）
• 引用一旦初始化后就不可以更改

理解：变量名本身就是自己所表示的值的一块内存空间，值的地址表示变量，因此，值与别名在某种意义上是等价的，所以引用必须要初始化，并且初始化后便不可更改

引用做函数参数

作用：函数传参时可以利用引用的技术让形参修饰实参

#include <iostream>
using namespace std;
void swap(int &a,int &b) {
	int temp = a;
	a = b;
	b = temp;
}
void main() {
	int a = 10;
	int b = 20;
	swap(a, b);
	cout << "a的值为：" << a << "\tb的值为：" << b << endl;
	system("pause");
}

结果：由此观之，引用传递，那么形参的改变会影响实参

引用做函数的返回值

前言：

• 引用是可以作为函数返回值存在的
• 不要返回局部变量的引用
• 引用的返回值类型：数据类型&
• 返回值为引用类型的函数那么其调用可以作为左值

具体案例

#include <iostream>
using namespace std;
//以引用的形式返回a
int& change() {
	//全局区的变量a
	static int a = 10;
	return a;
}
void main() {
	int &ref = change();
	//10
	cout << "ref的值为：" << ref << endl;
	cout << "ref的值为：" << ref << endl;
	system("pause");
}

#include <iostream>
using namespace std;
//以引用的形式返回a
int& change() {
	//全局区的变量a
	static int a = 10;
	return a;
}
void main() {
	int &ref = change();
	//相当于将a的引用赋值为1000
	change() = 1000;
	//因为ref为a的引用所以也为1000
	cout << "ref的值为：" << ref << endl;
	system("pause");
}

结论：若函数返回值类型为引用类型，则其函数调用可以作为左值

引用的本质

本质：在C++内部实现是一个指针常量

结论：C++推荐使用引用技术，因为语法方便，引用的本质是指针常量，但是所有的指针操作编译器都帮助我们做了

常量引用

作用：常量引用主要用来修饰形参，防止误操作

常量引用原理

#include <iostream>
using namespace std;
void main() {
	//加上const后，编译器将代码改为：int temp=10; int& ref=temp;
	const int& ref = 10;
	//下面报错，加了const后引用的值不可更改
	//ref = 20;
	cout << "ref的值为：" << ref << endl;
	system("pause");
}

注意：加了const后，那么被引用的别名值不可被更改 

经典案例

#include <iostream>
using namespace std;
void showValue(const int& a) {
	//这里形参到的改变会影响实参，因此加const来防止误操作
	cout << "a的值为：" << a << endl;
}
void main() {
	int a = 100;
	showValue(a);
	system("pause");
}

函数的提高

函数的默认参数

前言：在C++中函数的形参列表中的形参是可以有默认值的

语法：
返回值类型 函数名(参数=默认值){
    函数体;
}

注意：

• 若某个位置已经有了默认值，那么从这个位置往后，从左到右都必须有默认值
• 若函数的声明有默认参数，那么函数的实现就不能有默认参数（函数的声明和函数的实现只能有1个有默认参数）
• 调用函数传递的实参从左到右依次与形参一一匹配，其中传入的参数会覆盖掉对应位置的默认值

具体案例

#include <iostream>
using namespace std;
int add(int a, int b=20, int c=30) {
	return a+b+c;
}
void main() {
	int sum=add(10);
	cout << "sum等于：" << sum << endl;//60
	system("pause");
}

函数的占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置

语法：
返回值类型 函数名(数据类型){
    函数体;
}

注意：占位参数也可以有默认值 

具体案例

#include <iostream>
using namespace std;
//占位参数
void func(int a,int) {
	cout << "占位参数实例！" << endl;
}
void main() {
	//占位参数函数的调用
	func(10, 20);
	system("pause");
}

#include <iostream>
using namespace std;
//占位参数的默认参数
void func(int a,int =10) {
	cout << "占位参数实例！" << endl;
}
void main() {
	//占位参数函数的调用
	func(10);
	system("pause");
}

函数的重载

含义：函数名相同，但参数列表不同，进而提高函数的复用性

函数重载满足的条件

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同或者参数个数不同，或者参数顺序不同

注意：函数的返回值不可以作为函数重载的条件的

#include <iostream>
using namespace std;
void func() {
	cout << "func的调用：" << endl;
}
void func(int a) {
	cout << "func(int a)的调用："<<a<< endl;
}
void main() {
	func();
	func(10);
	system("pause");
}

函数重载的注意事项

引用作为重载的条件

#include <iostream>
using namespace std;
void func(int &a) {
	cout << "func(int &a)的调用：" << endl;
}
void func(const int &a) {
	cout << "func(const int &a)的调用："<<a<< endl;
}
void main() {
	int a = 10;
	//调用第一个
	func(a);
	//调用第二个
	func(10);
	system("pause");
}

函数重载碰到函数默认参数

#include <iostream>
using namespace std;
void func(int a,int b=10) {
	cout << "func(int a,int b=10)的调用：" << endl;
}
void func(int a) {
	cout << "func(int a)的调用："<< endl;
}
void main() {
	int a = 10;
	//若传一个参数的话会出现二义性
	func(10,20);
	system("pause");
}

注意：当函数重载碰到默认参数时，会出现二义性，报错，应尽量避免这种情况。

内联函数

前言

含义：通过内存膨胀的方式，以空间换取时间的函数

本质：通过inline关键字将对应函数的代码放到代码区，进而避免了函数调用时在栈区临时开辟内存，进而减少了函数调用过程入栈和出栈的时间

目的：提高程序的运行速度

语法：

inline 返回值类型 方法名(参数列表){
    函数体;
}

具体案例

#include <iostream>
using namespace std;
inline void func(int num);
void main() {
	func(9);
}
inline void func(int num) {
	cout << "调用了内联函数，num值为：" << num << endl;
}

C++之异常处理机制

异常：在程序运行过程中发生了不正常的现象，阻止了程序的运行。

异常处理关键字

• throw：抛出异常
• try：测试一些有异常的代码
• catch：对上面所抛出的异常进行捕获并解决,进而代码可以继续向后运行

异常语法

try{
    可能出现异常的代码;
}catch(接收异常){
    处理异常;
}catch(接收异常){
    处理异常;
}catch(...){
    处理异常;
}

具体案例

#include <iostream>
using namespace std;
double test(double a, double b) {
	//对异常情况进行处理
	if (b == 0) {
		throw "被除数不能为0";
		//throw后，后面代码不执行
	}
	return a / b;
}
//主函数
void main() {
	try {
		cout <<"a/b的值：" << test(9, 0) << endl;
	}
	catch (const char* e) {
		cout << e << endl;
	}
	catch (...) {
		cout << "其他错误！" << endl;
	}
}

注意：

• throw抛出的异常信息支持多种类型，抛出的异常信息被catch内的内容接收
• throw抛出异常后，若没有catch进行捕获，那么后面的代码不执行
• 对于抛出的其他异常，catch后面可以用...来捕获

自定义异常处理

前言

​​​​​​​C++中提供了一些供我们使用的异常类

注意：使用上面的异常时需要加头文件#include <exception>同时也需要使用std命名空间

具体案例

#include <iostream>
#include <exception>
using namespace std;
class MyException :public exception {
public:
	//重写what函数
	const char* what()const {
		return "自定义的异常";
	}
};
void main() {
	try {
		//直接抛异常测试
		throw MyException();
	}
	catch (MyException& obj) {
		cout << obj.what() << endl;
	}
}

C++的文件操作

前言：

背景：程序运行时产生的数据都为临时数据，程序一旦运行结束都会被释放，通过文件可以将数据持久化

注意：C++中对文件操作需要包含头文件#include <fstream>

文件类型分为两种

• 文本文件：文件以文本的ASCII码的形式存储在计算机中
• 二进制文件：文件以文本的二进制形式储存在计算机中，用户一般不能直接读懂他们

注意：二进制不单单可以操作内置数据类型，同时也可以操作自定义数据类型 

操作文件的三大类

• ofstream：写操作
• ifstream：读操作
• fstream：读写操作

以文本的方式写文件 

写文件操作步骤

1. 包含头文件：#include <fstream>
2. 创建流对象：ofstream ofs;
3. 打开文件：ofs.open("文件路径",打开方式);
4. 写数据：ofs<<"写入的数据";
5. 关闭文件：ofs.close();

文件的打开方式

注意：文件打开方式可以配合使用，利用|操作符

例如：用二进制方式写文件：ios::binary|ios::out

具体案例

#include <iostream>
//包含文件的头文件
#include <fstream>
using namespace std;
//文本文件的写文件
void writeText() {
	//创建流对象
	ofstream ofs;
	//指定文件的打开方式
	ofs.open("C:\\All\\other\\test.txt", ios::out);
	//向文件中写内容
	ofs << "hello C++" << endl;
	//关闭文件
	ofs.close();
}
void main() {
	writeText();
}

注意：

• 文件路径可以使用相对路径以及绝对路径
• 写文件可以使用ofstream流对象或fstream流对象
• 文件写完了close关闭文件

以文本的方式读文件 

读文件操作步骤

1. 包含头文件：#include <fstream>
2. 创建流对象：ifstream ifs;
3. 打开文件并判断文件是否打开成功：ifs.open("文件路径",打开方式);
4. 读数据：四种方式进行读取
5. 关闭文件：ifs.close();

具体案例 

#include <iostream>
//包含文件的头文件
#include <fstream>
using namespace std;
//文本文件的读文件
void readText() {
	//创建流对象
	ifstream ifs;
	//打开文件并判断文件是否打开成功
	ifs.open("C:\\All\\other\\test.txt", ios::in);
	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
	//读取文件数据
	char buf[1024] = { 0 };
	while (ifs>>buf) {
		cout << buf << endl;
	}
	//关闭文件
	ifs.close();
}
void main() {
	readText();
}

注意：

• 判断文件是否打开成功：ifs.is_open()，若返回真则打开成功，反之打开失败
• 写文件可以使用ofstream流对象或fstream流对象
• 文件读完了close关闭文件

读文件的四种方法

方法1

void readText() {
	//创建流对象
	ifstream ifs;
	//打开文件并判断文件是否打开成功
	ifs.open("C:\\All\\other\\test.txt", ios::in);
	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
	//读取文件数据
	char buf[1024] = { 0 };
	while (ifs>>buf) {
		cout << buf << endl;
	}
	//关闭文件
	ifs.close();
}

注意：将文件内容写入buf数组，文件若读到末尾则会返回假的标志：ifs>>buf （将文件内容读进buf）

方法2 

void readText() {
	//创建流对象
	ifstream ifs;
	//打开文件并判断文件是否打开成功
	ifs.open("C:\\All\\other\\test.txt", ios::in);
	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
	//读取文件数据
	char buf[1024] = { 0 };
	while (ifs.getline(buf, sizeof(buf))) {
		cout << buf << endl;
	}
	//关闭文件
	ifs.close();
}

注意：ifs.getline(字符串首地址,读取的长度);为读取一行的意思，若读取到的有值就会返回真，反之返回假（字符串首地址表示将文件内容读到哪个地方）

方法3

使用前需要导入头文件：#include <string>

void readText() {
	//创建流对象
	ifstream ifs;
	//打开文件并判断文件是否打开成功
	ifs.open("C:\\All\\other\\test.txt", ios::in);
	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
	//读取文件数据
	string buf;
	while (getline(ifs, buf)) {
		cout << buf << endl;
	}
	//关闭文件
	ifs.close();
}

注意：getline(基础输入流, 准备好的字符串)，该函数为全局函数，若基础输入流能读到数据则返回真，反之返回假

方法4

void readText() {
	//创建流对象
	ifstream ifs;
	//打开文件并判断文件是否打开成功
	ifs.open("C:\\All\\other\\test.txt", ios::in);
	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
	//读取文件数据
	char c;
	while ((c=ifs.get())!= -1){
		cout << c;
	}
	//关闭文件
	ifs.close();
}

注意：该方法为从文件一个字符一个字符的读，若读到文件末尾EOF，则会返回假进而结束循环

以二进制的方式对文件进行写操作

二进制方式写文件主要利用流对象调用成员函数write

函数原型：ostream& write(const char* buffer,int len)

函数参数：字符指针buffer指向内存中的一段储存空间表示从哪开始写入文件，len是读写的字节数

具体案例 

#include <iostream>
//包含文件的头文件
#include <fstream>
using namespace std;
//二进制文件的写文件
class Person {
public:
	char m_Name[64];
	int m_Age;
};
void writeBin() {
	//创建流对象
	ofstream ofs;
	//打开文件
	ofs.open("C:\\All\\other\\bin.txt",ios::out|ios::binary);
	//写入文件内容
	Person p = { "张三",18 };
	ofs.write((const char*)&p, sizeof(Person));
	//关闭文件
	ofs.close();
}
void main() {
	writeBin();
}

二进制方式的读文件

二进制的读文件主要利用流对象调用成员函数read

函数原型：istream& read(char *buffer,int len);

参数解释：字符指针buffer指向内存中的一段储存空间表示读到哪个位置，len是读写的字节数表示读多少

#include <iostream>
//包含文件的头文件
#include <fstream>
using namespace std;
//二进制文件的读文件
class Person {
public:
	char m_Name[64];
	int m_Age;
};
void readBin() {
	//创建流对象
	ifstream ifs;
	//打开文件
	ifs.open("C:\\All\\other\\bin.txt", ios::in | ios::binary);
	//判断文件是否打开成功
	if (!ifs.is_open()) {
		cout << "文件打开失败！" << endl;
		return;
	}
	//读文件读到Person中
	Person p;
	ifs.read((char*)&p, sizeof(Person));
	cout << "姓名：" << p.m_Name << "\n年龄：" << p.m_Age << endl;
	//关闭文件
	ifs.close();
}
void main() {
	readBin();
}

注意：读自定义数据类型的对象时自定义的类型必须存在