C++语法入门

---

前言

介绍一些个人对C++语法的学习，正在慢慢完善

---

初识C++

#include  //引用输入输出流
/*引用注释*/
using namespace std; //使用命名空间std
int main() {		//主函数
	cin >> a;
    std :: cout << "int类型占用的空间：" << sizeof(int) << std::endl; 
    return 0;
}

大体上与C语言类似，有以下几个区别：

• < iostream >与C不同的是C++的库可以不带.h
• std命名空间，当不使用.h文件时类和函数都在std里声明，声明了std就可以去掉std::
• cin、cout分别为输入输出流对象
• <<、>>分别为插入运算符与提取运算符
• endl为末尾结束换行，还具备了刷新数据打印缓冲区的功能
• ::类标识符，表示后面属于前面，类似C结构体调用
• return执行完后跳出函数

基于过程的程序设计

一、数据类型与基本运算

1.1 C++数据类型

数据类型	声明
整数类型	int
单精度浮点数	float
双精度浮点数	double
字符	char
字符串	string
布尔	bool

1. 常量

常量其实和变量没有多大区别，有名字，占据存储空间，可以是任何的基本类型，但只有一点不同，常量的值不允许变更。C++中的常量的声明需要使用const 关键字，而python中的常量默认约定是全大写表示。

int main(){ 
	const double pi {3.1415926};
	pi = 2.5 ; //将会出现编译错误 
	return 0 ; 
}

2. 变量

1.可以包含字母 、 数字 和下划线
2.必须以字母或者下划线开始

int age ; //未初始化
int age1 = 21 ; // C 方式初始化
int age2 (21); //构造方法初始化
int age3 {21} ; //c++ 11标准开始的方式

1.2 C++运算符

1. 算术运算符

基本运算符有+，-，*，/，%，运算中有一个数为float型数据，则运算结果为double型
强制类型转换运算符，格式：(类型名)表达式

(int)(x+y)

2. 赋值运算符

赋值运算符就是=

3. 逗号运算符

C++提供逗号运算符，表示表达式按顺序连接起来

a = 3*5,a*4

二、程序初步设计

2.1 C++输入与输出

任何编程语言都要输入和输出，python的输入输出是input 和 print , C语言的输入输出是 scanf 和 printf ，而C++的相对要复 杂些，它使用 std::cin 和 std::cout 来操作输入输出 。 C++的输入输出，需要导入iostream库

• 2.1.1 输入

std::cout << "请输入您的年龄："<<std::endl;

endl 来表示输出结束，它除了含有换行的功能之外，还具备了刷新数据打印缓冲区的功能

• 2.1.2输出

//由于没有换行，两个单词会出于同一行。
std::cout << "Hello"; std::cout << " world";

//兼备换行的输出
std::cout << "Hello" << std::endl; std::cout << " world" << std::endl;

//可以连续输出打印，这其实是一种叫做：链式调用的手法
std::cout << "Hello " << " World" << " , I love C++!" << std::endl;

2.2 逻辑关系运算

• 2.2.1 关系运算符

Operator	符号
等于	==
不等于	！=
大于	>
小于	<
大于或等于	>=
小于或等于	<=

• 2.2.2 逻辑运算符

Operator	符号
与	&&
或	｜｜
非	！

• 2.2.3 三元表达式

char result = score > 90 ? 'A' : 'B';

2.3 条件选择结构

• 2.3.1 if-else语句

if( score > 90){
	std::cout << "可以休息一天" << std::endl; }
else if(score > 80){
	std::cout << "可以休息半天" << std::endl; 
	}else{
		std::cout << "乖乖去写作业" << std::endl; 
}

• 2.3.2 switch语句

switch (level){
	case 'A':
		std::cout << "优秀" << std::endl;
		break;
	case 'B': 
	std::cout << "良好" << std::endl;
	break;
}

2.4 循环结构

• 2.4.1 while

int count = 0 ;
while(count < 10){
	std::cout << "红灯还在亮着..." << std::endl;
	//单位是毫秒
	Sleep(1000);
	count++;
}

• 2.4.2 do-while

int count = 0 ;
do{
	std::cout << "红灯还在亮着..." << std::endl;
	//单位是毫秒
	Sleep(1000);
	count++;
}while(count < 10);

• 2.4.3 for

for(int cout = 0 ; cout < 10 ; cout ++)
	std::cout << "红灯还在亮着..." << std::endl;

• 2.4.4 continue 和 break

continue：跳出本次循环，进入下一个循环
break：跳出循环体

int number = 1 ;
while(number <= 20){
	if(number == 16){
		break;
	}
	//满足条件，表示当前的number是奇数。
	if(number % 2 != 0 ){
		continue;
	}
	std::cout << "当前打印的数字是： " << number << std::endl;
	number++;
}

三、函数

3.1 函数的定义

• 3.1.1 无返回值无参数

void say_hello(){ 
	cout << "你好 " << endl; 
}

• 3.1.2 无返回值有参数

void say_hello(string name){ 
	cout << "你好 "<< name << endl; 
}

• 3.1.3 有返回值无参数

string say_hello(){ 
	return "你好 张三"; 
}

• 3.1.4 有返回值有参数

string say_hello(string name){ 
	return "你好 "+ name; 
}

3.2 函数调用

#include  
using namespace std; 
//函数声明，如果函数调用在函数定义之前，则需要进行函数声明，从而初始化函数
int add (int a , int b); 
int main(){ 
	cout << add(1 ,2)<< endl; return 0 ; 
}
//函数定义 ，函数的真正实现。 
int add(int a , int b){ 
	return a + b ; 
}

3.3 函数参数

• 3.3.1 值传递

#include 
using namespace std; 
void scale_number(int num); 
int main(){ 
	int number{1000}; 
	scale_number(number); 
	//打印number 1000 
	cout << number << endl; 
	return 0 ; 
}
void scale_number(int num){ 
	if(num > 100) num = 100; 
}

• 3.3.2 传递引用

#include 
using namespace std; 
void scale_number(int &num); 
int main(){ 
	int number{1000};
	scale_number(number); 
	//打印number100 
	cout << number << endl; 
	return 0 ; 
}
void scale_number(int &num){ 
	if(num > 100) num = 100; 
}

四、数组

4.1 声明和初始化

数组是一系列相同类型的元素，放置在连续的内存位置，数组中的元素都可以通过索引来单独操作它们。 若查看某个变量存储地址可以使用 取地址符 &

//1. 声明后再初始化
int scores [5];
scores[0] = 11; scores[1] = 22; scores[2] = 33; scores[3] = 44; scores[4] = 55; 
//2. 声明并初始化
int scores2 [5]{100,89,95,70,80};
//3. 自动推算数组大小
int scores3[]{22,33,44,55,66};

4.2 访问数组

4.2.1 获取数组中的某个元素

std::cout<<"数组的第一个元素是: "<< scores[0]<<std::endl;

4.2.2 遍历数组

int main(){ 
	//定义数组
	int scores[]{100,95,97,88,85,80,75};
	//直接指定数组
	for(int i = 0; i < 7; i++){
		std::cout << scores[i] << std::endl;
	}
	//手动计算数组长度
	int length = sizeof(scores) / sizeof(int);
	for(int i = 0 ; i < length; i++){
		std::cout << scores[i] << std::endl;
	}
	//c++11 提供的for循环
	for(int score : scores){
		std::cout <<score << std::endl;
	}
	return 0 ;
}

4.3 字符串

C++ 标准库提供了 string 类类型,支持上述所有的操作，另外还增加了其他更多的功能。需要引入 #include< string>，由于string类声明在命名空间 std ,所以在使用的首要注意 命名空间的联合使用 。

//引入string库 
#include  
using namespace std; 
int mian(){ 
	string s1; 
	string s2 {"北京"}; 
	string s3{s2}; 
	string s4 = "你好"; 
	s1 = s3; 
	return 0 ; 
}

4.4 Vector

Vector其实很大程度上和数组一样，只是数组是固定长度，而vector是不定长度（动态增长）。vector 在C++STL(标准模板库)中的一个容器，可以看成是对容器的一种扩展。

• 4.4.1 声明和初始化

#include  
using namespace std; 
int main(){ 
	vector <char> vowels2(5); //声明一个初始大小为5的char类型 
	vector <char> vowels {'a' , 'e' , 'i' , 'o' ,'u'};
	return 0; 
}

• 4.4.2 访问vector

#include  
#include  
using namespace std; 
int main(){ 
	vector<int> test_score {100,90,85}; 
	//以数组方式
	cout << "第一个成绩是: " <<test_score[0] << endl;
	cout << "第二个成绩是: " <<test_score[1] << endl;
	cout << "第三个成绩是: " <<test_score[2] << endl;
	cout << "第三个成绩是: " <<test_score[3] << endl;//不会检查越界 
	//vector的语法
	cout << "第一个成绩是: " <<test_score.at(0) << endl;
	cout << "第二个成绩是: " <<test_score.at(1) << endl;
	cout << "第三个成绩是: " <<test_score.at(2) << endl;
	cout << "第三个成绩是: " <<test_score.at(3) << endl; // 抛出越界异常
	return 0 ; 
}

• 4.4.3 操作vector

①修改vector中的元素

vector<int> test_score {100,90,85};
test_score.at(0) = 73;

②往vector中追加元素

vector<int> test_score {100,90,85};
test_score.push_back(80); // 100 , 90 , 85 , 80

③遍历vector

//使用下标遍历 
vector<int> scores{ 100 ,95 ,88 ,80 ,75}; 
for (int i = 0; i < scores.size(); ++i) { 
	cout << scores[i] << endl; 
}
//基于范围for遍历 
vector<int> scores2{ 100 ,95 ,88 ,80 ,75}; 
for(int score : scores2){ 
	cout << score << endl; 
}

五、指针

5.1 什么是指针

指针其实就是一个变量，不过它的值是一个内存地址 ， 这个地址可以是变量或者一个函数的地址

5.2 声明和初始化

• 5.2.1 声明指针

#include  
int main(){ 
	//初始化指针 
	int a = 3 ; 
	int *p0 = &a; 
	//p0是一个指针，指向的是一个int类型的数据，这个 数据是3.
	//空指针，没有指向任何地方 
	int *p1 = nullptr;
	int *p2 = NULL;
	int *p3 = 0 ; 
	return 0 ; 
}

• 5.2.2 栈内存

#include  
int main(){ 
	int age = 88; 
	int *p = &age; 
	//函数执行结束， age所占用空间会自动回收 
	return 0 ; 
}

• 5.2.3 堆内存

#include  
int main(){ 
	//使用new的方式在堆内存中开辟空间。 
	int *p = new int(88); 
	//需要手动配合delete 删除 
	delete p ; 
	return 0 ; 
}

5.3 函数与指针

• 5.3.1 参数传递指针

函数的参数，除了传递普通的变量，引用之外，还可以把指针当成参数来传递

#include 
using namespace std; 
//函数原型 
void double_data(int *int_ptr); 
int main(){ 
	int value{10}; 
	//修改前，输出为10 
	cout << value << endl; 
	//在函数内部修改value的值 
	double_data(&value); 
	//修改后，输出为20 
	cout << value << endl; 
}
void double_data(int *int_ptr){ 
	*int_ptr *=2; 
}

• 5.3.2 函数返回指针

函数平常除了返回标准的数值之外，其实也可以返回指针。

#include  
using namespace std; 
//返回两个参数中的最大者 
int *calc_largest(int *ptr1 , int *ptr2); 
int main(){ 
	int a = 100; 
	int b = 200; 
	//使用指针指向最大数值 
	int *largest_ptr = calc_largest(&a , &b); 
	//输出：200 
	cout << *largest_ptr << endl ; 
	return 0 ; 
}
int *calc_largest(int *ptr1 , int *ptr2){ 
	//解引用获取到数据后比较 ： 
	if(*ptr1 > *ptr2){ 
		return ptr1; 
	}else{
		return ptr2; 
	} 
}

5.4 引用

引用，顾名思义是某一个变量或对象的别名，对引用的操作与对其所绑定的变量或对象的操作完全等价。引用在使用时，有几个要注意的地方：

1. &不是求地址运算符，而是起到标志作用
2. 引用的类型和绑定的变量类型必须相同 (指针也一样) 3. 声明引用的同时，必须对其进行初始化，否则报错。
3. 引用不是定义一个新的变量或对象，因此内存不会为引用开辟新的空间存储这个引用
4. 不能建立数组的引用。因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名。

int main(){ 
	//语法：类型 &引用名=目标变量名； 
	int a = 3 ; 
	int &b = a ; 
	//此时a也会变成33 
	b = 33; 
	vector<string> names {"张三" , "李四" ,"王五"}; 
	// 这仅仅是改变了str的值，并不会改变vector里面的元素
	for(auto str:names){ str = "赵六"; }
	//此处不会产生新的变量，所以修改的都是vector里面的元素
	for(auto &str : names){ str = "赵六" ; }
	return 0 ; 
}

六、自定义数据类型

6.1 结构体

结构体与数组的区别就是，结构体可以包含不同类型的数据项

struct Student		//用struct来声明结构体
{int num;
char name[20];
char sex;
int age;
float score;
}student1 = {10001,"zhang Xin",'F',20,18};	//初始化
Student student2 = {10002,"Wang Li",'F',20,68};

结构体指针3种形式等价：
①结构体变量.成员名。如stu.num
②(*p).成员名。如(*p).num
③p -> 成员名。如p -> num

6.2 枚举类型

如果变量的值确定，则可以定义枚举类型

enum weekday	//用enum申明枚举类型
{
	sun,mon,tue,wed,thu,fri,sat
};

6.3 用typedef声明新的类型名

typedef float REAL;		//用REAL代表float类型

6.4 new和delete运算符

C++用new和delete取代malloc与free来动态分配和撤销存储空间

p = new Student; 	//用new开辟一个存放Student型数据的空间，地址赋给p
delete p;

面向对象的程序设计

七、类和对象的特性

对象是一类东西， 而类是构成对象的一个基石，从而描述对象的特征

7.1 类

#include 
#include  
using namespace std; 
class student{ 
	private: 
		string name; // 姓名 
		int age; //年龄 
	public: 
		void read(){ 
			std::cout << "学生在看书" << std::endl; 
		} 
};

7.2 对象

• 7.2.1 在栈中创建对象

用这种方法创建的对象，内存分配到栈里（Stack）。 直接使用 来访问成员。当程序对象所在的代码块结束运行（方法运行结束），对象会自动删除，内存自动释放。

#include 
using namespace std; 
class student{ 
	public: 
		void run(){ 
			cout << "学生在跑步" << endl; 
		} 
};
int main(){ 
	//对象存储于栈内存中 
	student stu1 ; 
	stu1.run(); 
	return 0 ; 
}

• 7.2.2 在堆中创建对象

这种方法创建的对象，内存分配到堆里（Heap）。一般使用* 或者 - >调用对象的方法。箭头操作符”->"将解引用（dereferencing* ）和成员使用（member access.）结合起来

#include 
#include 
using namespace std; 
class student{ 
	public: 
		void run(){ 
			cout << "学生在跑步" << endl; 
		}

};
int main(){ 
	//对象存储于栈内存中 new 关键字是在堆中申请内存 
	student *s3 = new student; 
	s3->run(); 
	//采用解引用的方式之后，再进行成员访问 
	(*s3).run(); 
	return 0 ; 
}

7.3 访问修饰符

c++ 对于成员的访问有三种访问操作符 public | private | protected ， 默认情况下是private

1. public : 公开权限，任何位置都可以访问
2. private : 私有权限，只能自己内部访问及其友元类和函数
3. protected : 受保护权限，只能在自己内部、子类及友元类和函数访问

#include 
#include 
using namespace std; 
class student{ 
	private: //表示下面的成员为私有 
		string name; // 姓名 
		int age; //年龄 
	public: //表示下面的函数为公开 
		void run(){} }
;
int main(){ 
	student stu ;
	stu.name = "张三" ; // 禁止访问 , 会报错 
	stu.run(); //允许访问 
	return 0 ; 
}

7.4 实现类的成员函数

1. 成员函数可以在类里面直接实现，也可以在类的外部实现
2. 可以在类的外部实现成员函数 ， 但是需要使用类名::函数名来标记函数

#include  
#include  
using namespace std; 
class student{ 
	private : 
		int age ; 
		string name; 
	public : 
		void read(string bookname){ 
			cout<< bookname << endl; 
		}
		void speak(string something); 
};

void student::speak(string something){ 
	cout << "说说说---" << something << endl; 
}
int main(){ 
	student stu;
	stu.read("哈利波特"); 
	stu.speak("我喜欢看哈利波特"); 
	return 0 ;
}

八、类和对象的使用

当定义一个类后，它的对象在未来的操作中，总会不可避免的总会碰到如下的行为：创建 、拷贝 、赋值 、移动 、销毁 。这些操作实际上是通过六种特殊的成员函数来控制的：构造函数 、析构函数、拷贝构造函数 、拷贝赋值函数 、移动构造函数、移动赋值函数 。默认情况下，编译器会为新创建的类添加这些函数 （默认不会添加移动构造和移动赋值），以便它的对象在未来能够执行这些操作。

8.1 构造函数与析构函数

1. 构造函数是类的一种特殊的成员函数，它会在每次创建对象时执行。它与类名同名，没有返回值，可以被重载，通常用来做初始化工作。
2. 析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。不能被重载，一般用于释放资源。

#include  
#include  
using namespace std; 
class student{ 
	string name; 
	int age ; 
	public : 
		//构造函数 
		student(){ 
			cout << "执行无参构造函数" <<endl;	
		}
		student(string name ){ 
			cout << "执行含有一个参数的参构造函数" <<endl;
		}
		student(string name , int age ){ 
			cout << "执行含有两个参数的构造函数" <<endl; 
		}、
		//更好的构造方式 
		student(string name ,int age):name{name},age{age}{ 
			cout << "执行有参构造函数" <<endl; 
		}
		//析构函数{} 
		~student(){ 
			cout << "执行析构函数" <<endl; 
		} 
};
int main(){ 
	student *s1 = new student(); 
	student s2{"张三"}; 
	student s3{"张三",28};
	//释放对象 
	delete s1; 
	return 0 ; 
}

8.2 拷贝构造函数

C++中经常使用一个常量或变量初始化另一个变量，表面上相当于将s1中每个数据成员的值复制到s2中。实际上，系统调用 了一个拷贝构造函数。

class student{ };
int mian(){
	int a = 3; 
	int b = a; 
	student s1; 
	student s2 = s1; 
	return 0 ; 
}

• 8.2.1 浅拷贝

指的是在对象复制时，只对对象中的数据成员进行简单的赋值，编译器提供的拷贝操作即是浅拷贝，默认拷贝构造函数执行的也是浅拷贝。如果数据中有属于动态成员 ( 在堆内存存放 )，那么浅拷贝只是做指向而已，不会开辟新的空间。
默认情况下，浅拷贝已经足以应付日常的需求了，但是当类中的成员存在动态成员（指针）时，浅拷贝往往会出现一些奇怪的问题。由于address是指针类型，如果是浅拷贝， 那么两个指针会指向同一个位置。

• 8.2.2 深拷贝

深拷贝 也是执行拷贝，只是在面对对象含有动态成员或指针时，会执行新内存的开辟，而不是作简单的指向。在发生对象拷贝的情况下，如果对象中存在动态成员，就不能仅仅简单地赋值了，而应该重新分配空间。

#include  
#include  
using namespace std; 
class student { 
	public: 
		string name; 
		string *address=nullptr; 
		student(string name , string * address):name(name),address(address){ 
			cout << "执行构造函数" << endl; 
		}
		//深拷贝 
		student(const student & s){ 
			cout << "调用了拷贝构造函数" << endl; 
			name = s.name; 
			if(address == nullptr){ 
				//开辟新的空间 
				address = new string(); 
				*address = *s.address; 
			} 
		}
		//析构函数 
		~student(){ 
			cout << "调用了析构函数" << endl; 
			if(address != nullptr){ 
				delete address; address = nullptr; 
			} 
		}
};
int main(){ 
	string *address= new string("深圳"); 
	student s1("张三" , address); 
	//此处会执行拷贝。 
	student s2 = s1; 
	cout << s1.name << " : " << *(s1.address) << endl;
	cout << s2.name << " : " << *(s2.address) << endl;
	//修改第一个学生的地址为：北京 
	*(s1.address) = "北京"; 
	//第二个学生的地址不会变成北京 
	cout << s1.name << " : " << *(s1.address) << endl;
	cout << s2.name << " : " << *(s2.address) << endl;
	return 0 ; 
}

九、重载、继承和派生

9.1 运算符重载

重载就是对已有的东西赋予新的含义

运算符重载一般格式：
函数类型 operator 运算符名称 (型参表)
{对运算符的重载处理}

int operator + (int a,int b)
{return (a+b);}

9.2 继承和派生

继承和派生的概念
一个新类从已有的类建立一个新类就是继承，而新产生的子类就是类的派生

派生类的声明方式：
> class 派生类名:[继承方式] 基类名
{
派生类新增加的成员
};
注：如果不写继承方式，默认为private（私有的）

Class Student { //声明基类
public: //基类公用成员
	void get_value() //输入基类数据的成员函数
	{cin>>num>>name>>sex;}
	void display() //输出基类数据的成员函数
	{
		cout<<" num: "<<num<<endl;
		cout<<" name: "<<name<<endl;
		cout<<" sex: "<<sex<<endl;
	}
private : //基类私有成员
	int num;
	string name;
	char sex;
};
class Student1: public Student { //以public方式声明派生类Student1
public:
	void get_value_1() //输入派生类数据
	{cin>>age>>addr;}
	void display_1()
	{
		cout<<" num: "<<num<<endl; //试图引用基类的私有成员，错误
		cout<<" name: "<<name<<endl; //试图引用基类的私有成员，错误
		cout<<" sex: "<<sex<<endl; //试图引用基类的私有成员，错误
		cout<<" age: "<<age<<endl; //引用派生类的私有成员，正确
		cout<<" address: "<<addr<<endl;
	} //引用派生类的私有成员，正确
Private:
	int age;
	string addr;
};

十、多态性和虚函数

10.1 多态性概念

多态性：向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为(即方法)。

多态性分类：
静态多态性是通过函数重载实现的
动态多态性的特点是： 不在编译时确定调用的是哪个函数，而是在程序运行过程中才动态地确定操作所针对的对象。动态多态性是通过虚函数(virtual function)实现的。

10.2 利用虚函数实现动态多态性

虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数

#include 
#include 
using namespace std;
//声明基类Student
class Student {
	public:
		Student(int, string,float);//声明构造函数
		void display(); //声明输出函数
	protected://受保护成员,派生类可以访问
		int num;
		string name;
		float score;
};
//Student类成员函数的实现
Student∷Student(int n, string nam,float s) //定义构造函数
	{num=n;name=nam;score=s;}
void Student∷display()//定义输出函数
	{cout<<"num:"<<num<<"\\nname:"<<name<<"\\nscore:"<<score<<"\\n\\n";}
//声明公用派生类Graduate
class Graduate:public Student {
	public:
		Graduate(int, string, float, float);//声明构造函数
		void display(); //与基类的输出函数同名
	private:
		float wage;
};
// Graduate类成员函数的实现
Graduate∷Graduate(int n, string nam,float s,float w):Student(n,nam,s),wage(w) {}
void Graduate∷display()//定义输出函数
	{cout<<"num:"<<num<<"\\nname:"<<name<<"\\nscore:"<<score<<"\\nwage="<<wage<<endl;}
//主函数
int main()
{
	Student stud1(1001,"Li",87.5); //定义Student类对象stud1
	Graduate grad1(2001,"Wang",98.5,1200);//定义Graduate类对象grad1
	Student pt=&stud1;//定义指向基类对象的指针变量pt,指向stud1
	pt->display(); //输出Student(基类)对象stud1中的数据
	pt=&grad1;//pt指向Graduate类对象grad1
	pt->display();//希望输出Graduate类对象grad1中的数据
	return 0;
}

10.3 纯虚函数与抽象类

纯虚函数：在声明虚函数时被“初始化”为0的函数。作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对它进行定义。其格式为：
virtual 函数类型 函数名 (参数表列) =0;

抽象类：这种不用来定义对象而只作为一种基本类型用作继承的类，称为抽象类(abstract class)，由于它常用作基类，通常称为抽象基类(abstract base class)。

十一、输出输入流

C++的输入输出流是指由若干个字节组成的字节序列，这些字节中的数据按顺序从一个对象传送到另一个对象。总之，流是与内存缓冲区相对应的，或者说，缓冲区中的数据就是流。

ios是“输入输出流”，streambuf是处理“流缓冲区”的类，包括缓冲区起始地址、读写指针和对缓冲区的读写操作，是数据在缓冲区中的管理和数据输入输出缓冲区的实现。I/O类库中的常用流类：

11.1 标准输出流与输入流

11.2 文件流与文件操作

1. 文件的打开与关闭

一般形式为：
文件流对象.open(磁盘文件名,输入输出方式);
文件输入输出方式设置值：

方式	作用
ios::in	以输入方式打开文件
ios:out	以输出方式打开文件，如果文件存在，则将其原有内容清除
ios::app	以输出方式打开文件，写入的数据添加在文件末尾
ios::ate	打开已有文件，文件指针指向文件末尾
ios::trunc	打开文件，如果文件存在则删除其数据；不存在则创建文件
ios:binary	以二进制方式打开一个文件
ios::nocreate	打开一个已有文件，如果文件不存在，则打开失败
ios::noreplace	如果文件不存在则建立文件，如果存在则操作失败
ios::in ｜ ios::out	以输入输出方式打开文件
ios::binary ｜ ios::out	以二进制方式打开一个输出文件
ios::in ｜ ios::binary	以二进制方式打开一个输入文件

ofstream outfile;//定义ofstream类(输出文件流类)对象outfile
outfile.open("f1.dat",ios∷out);//使文件流与f1.dat文件建立关联
outfile.close();//将输出文件流所关联的磁盘文件关闭所谓关闭

outfile.open("f2.dat",ios∷app|ios∷nocreate);此时文件流outfile与f2.dat建立关联，并指定了f2.dat的工作方式。

2. 对二进制文件的读写

字符指针buffer指向内存中一段存储空间。len是读写的字节数。其一般格式为：

istream& read(char *buffer,int len);
ostream& write(const char *buffer,int len);

C++扩展

一、C++工具

1.异常处理

异常处理指的是，对运行时出现的差错以及其他例外情况的处理 。C++异常处理由3个部分组成：检查(try)、抛出(throw)和捕捉(catch)。如果出现异常，可以发出一个信息，由上级捕捉信息后处理

void f3()
{double a=0;
try		//在try中包括要检测的部分
	{throw a;}   //throw执行后会立刻返回上一级函数
catch(float)	//用catch捕捉异常并处理

	{cout << "ERROR!" << endl;}
}

2.命名空间

可以使用 using namespace指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。
本质上，命名空间就是定义了一个范围。它可作为附加信息来区分不同库中相同名称的函数、类、变量等。

#include 
using namespace std;
int main(){
	cout<<"hi c++" << endl;
	return 0 ;
}

结语

关于python语法的学习见以下文章
https://blog.csdn.net/weixin_44567668/article/details/125189798