C++|Cpp基础语法（二） C++|c++

Cpp基础语法（二）
OVERVIEW

Cpp基础语法（二）
- - - 1.内存的分区模型
    - - （1）代码区：
      - （2）全局区：
      - （3）栈区：
      - （4）堆区imp：
      - （5）new操作符：
    - 2.C++中的引用
    - - （1）引用的基本使用：
      - （2）引用做函数参数：
      - （3）引用做函数返回值：
      - （4）引用的本质：
      - （5）常量引用：
    - 3.函数高级
    - - （1）函数的默认参数：
      - （2）函数的占位参数：
      - （3）函数重载：
      - （4）函数重载特殊问题（难点）：
      - case1：引用作为函数的重载条件
        
        case2：函数重载遇到函数的默认参数
    - 4.C++文件操作：
    - - （1）文本文件：
      - <1>指定文件打开方式：
        
        <2>文本文件的写操作：
        
        <3>文本文件的读操作：
      - （2）二进制文件：
      - <1>二进制文件的写操作：
        
        <2>二进制文件的读操作：

1.内存的分区模型

Cpp程序在执行时，将内存大方向划分为4个区域：代码区、全局区、栈区、堆区

文章图片

代码区：存放函数体的二进制代码，由操作系统进行管理
全局区：存放全局变量、静态变量、及常量
栈区：由编译器自动分配释放，存放函数的参数值、局部变量等
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统进行回收

内存分区的意义：不同区域存放的数据，赋予了不同的生命周期，给我们更大的灵活编程

（1）代码区：代码区主要存放了CPU执行的机器指令。
代码区内容是共享的，目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区内容是只读的，目的是防止程序意外的修改了它的指令
（2）全局区：全局区主要存放了全局变量、静态变量（static）、及常量
全局区的数据在程序结束后由操作系统控制释放（生命周期由操作系统管理）

文章图片

注意：代码区域全局区的概念是在代码运行前就有的概念，而栈区和堆区是在程序运行后才有的概念

（3）栈区：栈区由编译器自动分配释放，主要存放内容是函数的参数值、局部变量等

注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放（生命周期结束）

（4）堆区imp：堆区由程序员分配和释放，若程序员不释放，程序结束时由操作系统进行回收。
在C++中主要使用new关键字在堆区进行内存的开辟。
（5）new操作符： C++中利用new操作符在堆区开辟内存，利用操作符delete释放堆区内存；
语法：new 数据类型，利用new创建的数据，会返回该数据相应类型的指针

#include using namespace std; int * func() { //利用new关键字在堆区开辟内存，返回地址 //指针本质也是局部变量，放在栈上，指针保存的数据是放在堆区 int * p = new int(10); return p; }//1.new的基本语法 void test01() { int *p = func(); cout << *p << endl; cout << *p << endl; cout << *p << endl; //释放变量堆区内存 delete p; cout << *p << endl; }//2.在堆区中开辟一个数组 void test02() { int * arr = new int[10]; //10代表数组有10个元素for (int i = 0; i < 10; ++i) { arr[i] = i + 100; } for (int i = 0; i < 10; ++i) { cout << arr[i] << endl; } //释放数组堆区内存 delete[] arr; }int main() { //1.new的基本语法 test01(); //2.在堆区利用new开辟数组 test02(); system("pause"); return 0; }

2.C++中的引用（1）引用的基本使用：作用：给变量起别名
语法：数据类型 &别名 = 原名

#include using namespace std; int main(){ int a = 10; //创建引用 int &b = a; cout << "a = " << a << endl; cout << "b = " << b << endl; system("pause"); return 0; }

文章图片

注意：

引用必须进行初始化（不允许出现int &b;）

引用在初始化之后，便不可以再改变（c = b;赋值操作，不是在更改引用）

文章图片

（2）引用做函数参数：作用：函数传递参数时，可以利用引用技术让形参修饰实参。
优点：可以简化指针修改实参，

#include using namespace std; //交换函数 //1.值传递 void mySwap01(int a, int b) { int temp = a; a = b; b = temp; } //2.地址传递(用指针接收地址) void mySwap02(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } //3.引用传递() int mySwap03(int &a, int &b) { int temp = a; a = b; b = temp; }int main(){ int a = 10; int b = 20; //mySwap01(a, b); //值传递，形参不会修饰实参 //mySwap02(&a, &b); //地址传递，形参会修饰实参 mySwap03(a, b); //引用传递，形参会修饰实参cout << "a = " << a << endl; cout << "b = " << b << endl; system("pause"); return 0; }

文章图片

总结：通过引用参数产生的效果同按地址传递是一样的效果，引用的语法更清楚简单。

（3）引用做函数返回值：作用：引用是可以作为函数的返回值存在的
用法：函数调用作为左值

注意：

不要返回局部变量引用

函数的调用可以作为左值存在

#include using namespace std; //引用做函数返回值 //1.不要返回局部变量的引用 int& test01() { int a = 10; //局部变量存放在四区中的栈区 return a; } //2.函数的调用可以作为左值 int& test02() { static int a = 10; //静态变量存放在四区中的全局区，全局区上的数据在程序结束后由系统释放 return a; }int main(){ //1.不要返回局部变量的引用 int &ref = test01(); //在test01中将a的别名进行返回，在main函数中使用ref接住 //cout << "ref = " << ref << endl; //第1次结果可能会正确，是因为编译器做了保留 //cout << "ref = " << ref << endl; //第2次结果错误，因为a的内存已经释放(非法操作)int &ref2 = test02(); cout << "ref2 = " << ref2 << endl; //第1次结果可能会正确，是因为编译器做了保留 cout << "ref2 = " << ref2 << endl; //第2次结果也是正确，只有在整个程序执行完后才会被释放//2.函数的调用可以作为左值 test02() = 1000; //如果函数的返回值是引用，那么这个函数调用可以作为左值 cout << "ref2 = " << ref2 << endl; cout << "ref2 = " << ref2 << endl; system("pause"); return 0; }

（4）引用的本质：本质：在C++内部实现的一个指针常量（一旦初始化后就不可发生改变）

#include using namespace std; //发现是引用，转换为 int* const ref = &a; void func(int& ref) { ref = 100; //ref是引用，转换为*ref = 100 }int main() { int a = 10; int& ref = a; //自动转换为int* const ref = &a; 指针常量是指针指向不可改变，也说明为什么引用不可改变 ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20; cout << "a : " << a << endl; cout << "b : " << b << endl; func(a); return 0; }

注：C++推荐使用引用技术（语法方便），其本质是指针常量（所有的指针操作编译器都帮我们完成了）

（5）常量引用：作用：常量引用主要用来修饰形参，防止误操作
语法：const 数据类型 &别名

注：在形参列表中可以使用const修饰形参，防止形参改变实参

#include using namespace std; //发现是引用，转换为 int* const ref = &a; void showValue(const int &val) { cout << "val = " << val << endl; }int main() { //常量引用 //使用场景：修饰形参，防止误操作/* int a = 10; int& ref = a; //1.引用必须应用一块合法的内存空间(栈区or堆区)，常量10在常量区(int& ref = 10; 为非法) const int& ref = 10; //2.加上const之后编译器可自动将代码修改为int temp = 10; const int& ref = temp; */ int a = 100; showValue(a); cout << "a = " << a << endl; return 0; }

3.函数高级

注：在C++中有更深的一种用法

（1）函数的默认参数：在C++中函数的形参列表中的形参是可以有默认值的，
语法：返回值类型函数名 (参数 = 默认值) {...}

注意：

如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值

如果函数声明有默认参数，则函数实现就不能有默认参数（声明和实现只能有一个有默认参数）

#include using namespace std; //函数的默认参数,如果传入数据就用自己的数据，否则使用默认值 int func(int a, int b = 20, int c = 30) { return a + b + c; }/*注意: 1.如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值 2.如果函数声明有默认参数，则函数实现就不能有默认参数 */ int main() { cout << func(10, 100) << endl; system("pause"); return 0; }

文章图片

（2）函数的占位参数： C++中函数的形参列表里可以有占位参数用来做占位，调用函数时必须填补该位置：
语法：返回值类型函数名(数据类型) {...}

注：在现阶段函数的占位参数存在的意义不大，但是后面的课程中会用到该技术。

#include using namespace std; //占位参数 //返回值类型函数名(数据类型) {} //目前阶段的占位参数还使用不到 void func(int a, int) { cout << "this is func" << endl; }int main() { func(10); return 0; }

（3）函数重载：作用：函数名可以相同，从而提高复用性
函数重载满足的条件：

同一个作用域
函数名称相同
函数参数类型不同 or 参数个数不同 or 参数顺序不同

#include using namespace std; //函数重载:可以让函数相同，提高代码复用性 /* 函数重载的满足条件 1.函数都在同一个作用域下(这里为全局作用域) 2.函数名称相同 3.函数参数类型不同 or 参数个数不同 or 参数顺序不同 */ void func() { cout << "func 函数的调用" << endl; }void func(int a) { cout << "func(int a) 函数的调用" << endl; }void func(double a) { cout << "func(double a) 函数的调用" << endl; }int main() { func(); func(10); func(3.14); return 0; }

文章图片

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

文章图片

（4）函数重载特殊问题（难点）： case1：引用作为函数的重载条件

#include using namespace std; //函数重载注意事项 //1.引用作为重载的条件(参数类型不同的函数重载) void func(int &a) { //int &a = 10; 引用必须在一个合法的内存空间(栈区or堆区)，10位于常量区不合法引用 cout << "func(int &a)函数的调用" << endl; } void func(const int &a) { //const int &a = 10; 编译器自动进行了优化：int temp = 10; const int &a = temp; 合法引用 cout << "func(const int &a)函数的调用" << endl; }int main() { int a = 10; func(a); //由于a为一个变量，为可读可写的状态，故传入参数后应该调用可读可写的函数func(int &a) func(10); //由于10位一个常量，故传入参数后应该调用函数func(const int &a)return 0; }

文章图片

case2：函数重载遇到函数的默认参数

#include using namespace std; //函数重载注意事项 //2.函数重载碰到默认参数 void func2(int a) { cout << "func2(int a)函数的调用" << endl; } void func2(int a, int b = 10) { cout << "func2(int a, int b = 10)函数的调用" << endl; }int main() { //当函数重载碰到默认参数，会出现二义性报错(应尽量避免这种情况) func2(10); return 0; }

文章图片

注意：当函数重载碰到默认参数，会出现二义性报错（代码15行应尽量避免这种情况）

4.C++文件操作：程序运行时产生的数据都属于临时的数据，随着程序运行的结束都会被释放，可以通过文件将数据持久化。

cpp中对文件操作需要包含头文件
文件类型分为两种：文本文件（以文本的ASCII码形式存储）、二进制文件（以二进制形式存储）
操作文件的文件流分为三类：ofstream写操作、ifstream读操作、fstream读写操作

（1）文本文件： <1>指定文件打开方式：

打开方式	说明
ios::in	只读
ios::out	只写
ios::ate	初始位置：文件尾
ios::app	追加
ios::trunc	若文件存在先删除，再创建
ios::binary	二进制方式

注意：文件的打开方式可以相互组合，利用|实现（例如：用二进制方式写文件为ios::binary | ios::out）

<2>文本文件的写操作：

#include //step1:包含头文件 ... ofstream ofs; //step2:创建流对象 ... ofs.open("文件路径", 打开方式)//step3:打开文件 ... ofs << "写入的数据"; //step4:向文件中写入数据 ... ofs.close(); //step5:关闭文件

#include #include using namespace std; //1.文本文件写文件 void test01(){ //(1)创建流对象 ofstream ofs; //(2)指定打开方式 ofs.open("test.txt", ios::out); //(3)向文件中写入数据 ofs << "author:luochenhao" << endl; ofs << "gender:male" << endl; ofs << "age:21" << endl; //(4)关闭文件 ofs.close(); }int main(){ test01(); system("pause"); return 0; }

【C++|Cpp基础语法（二）】

文章图片

在当前目录下创建了一个名为test.txt的文件，进行了向其中写入一些数据的操作。
<3>文本文件的读操作：

#include //step1:包含头文件 ... ifstream ifs; //step2:创建流对象 ... ifs.open("文件路径", 打开方式)//step3:打开文件，并判断文件是否成功打开 ... Data can be read in four ways//step4:从文件中读取数据 ... ifs.close(); //step5:关闭文件

#include #include using namespace std; //2.文本文件读文件 void test02(){ //(1)创建流对象 ifstream ifs; //(2)打开文件,并判断是否打开成功 ifs.open("test.txt", ios::in); if(!ifs.is_open()){ cout << "文件打开失败" << endl; return; } //(3)从文件中读取数据 cout << "方式1:利用while循环将文件中的数据全部放在buf字符数组中" << endl; char buf1[1024] = {0}; while(ifs >> buf1) { cout << buf1 << endl; }cout << "方式2:利用ifs的成员函数getline一行行将文件中的数据全部放在buf字符数组中" << endl; char buf2[1024] = {0}; while(ifs.getline(buf2, sizeof(buf2))) { cout << buf2 << endl; }cout << "方式3:利用全局函数getline一行行将文件中的数据全部放在的buf字符串中" << endl; string buf3; while(getline(ifs, buf3)){ cout << buf3 << endl; }cout << "方式4:利用ifs的成员函数get从文件中一个个字符进行读取" << endl; char c; while((c = ifs.get()) != EOF) { cout << c; } //(4)关闭文件 ifs.close(); }int main(){ test02(); system("pause"); return 0; }

文章图片

从当前目录下读取刚才新创建的test.txt文件，将信息输出在屏幕上。

疑问：4种读取数据的方式都可行，为什么只有一次文件结果的输出？

（2）二进制文件：以二进制的方式对文件进行读写操作，打开方式需要指定为ios::binary
<1>二进制文件的写操作：二进制方式写文件主要利用流对象调用成员函数write
函数原型：

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

参数解释：字符指针buffer指向内存中一段存储空间（数据地址），len是读写的字节数

#include #include using namespace std; //1.二进制文件写文件 class Person{ public: char name[64]; int age; }; void test01(){ //(1)创建流对象 ofstream ofs; //(2)指定打开方式 ofs.open("person.txt", ios::out|ios::binary); //(3)向文件中写入数据 Person p1 = {"luochenhao", 21}; ofs.write((const char *)&p1, sizeof(Person)); //(4)关闭文件 ofs.close(); }int main(){ test01(); system("pause"); return 0; }

文章图片

在当前目录下创建了一个名为person.txt的文件，进行了向其中以二进制的方式写入一些数据的操作。

注意：由于数据是以二进制的方式写入，直接打开person.txt文件后发现有些数据无法正常显示属于正常。

<2>二进制文件的读操作：二进制方式读文件主要利用流对象调用成员函数read
函数原型：

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

参数解释：字符指针buffer指向内存中一段存储空间（数据地址），len是读写的字节数

#include #include using namespace std; //2.二进制文件读文件 class Person{ public: char name[64]; int age; }; void test02(){ //(1)创建流对象 ifstream ifs; //(2)打开文件,并判断是否打开成功 ifs.open("person.txt", ios::in|ios::binary); if(!ifs.is_open()){ cout << "文件打开失败!" << endl; return; } //(3)从文件中读取数据 Person p2; ifs.read((char *)&p2, sizeof(Person)); cout << "姓名:" << p2.name << endl; cout << "年龄:" << p2.age << endl; //(4)关闭文件 ifs.close(); }int main(){ test02(); system("pause"); return 0; }