当初自学C++时的笔记记录

编辑:刘风琛

最初编写日期:2020年4月11日下午 最新更新日期:2020年9月20日上午

标注:

  • 从笔记开始截止到程序第四章“程序流程结构”,使用Joplin编写,其余部分为Typora编写。
  • 笔记对应课程链接为:(https://www.bilibili.com/video/BV1et411b73Z) 作者:黑马程序员-
  • 当前进度为P107:类和对象

目录

1. 变量

给一段内存起名,方便使用。

2. 常量

用于记录程序中不可更改的数据。

  • 定义常量的两种方式
    1. #define宏常量 #define 常量名 常量值
      • 通常在文件上方定义,表示一个常量。
    2. const修饰的变量 const 数据类型 常量名=常量值
      • 通常在变量定义前加const,修饰该变量为常量,不可更改。`

3. 数据类型

sizeof()可以返回当前数据类型所占内存大小。

  • 强制转换
    语法:(数据类型)被转变量
    举例:

    int main(){
    	char ch = 'a';
    	cout<<(int)ch<<endl;
    	return 0;
    }
    

    输出结果:97(字符a的ASCII码)

  • 转义字符
    转义字符用反斜杠\表示,可以用来表示ASCII码的特殊值。

转义字符 含义 ASCII码值
\a 警报 007
\b 退格(BS),将当前位置移到前一列 008
\f 换页(FF),将当前位置移到下页开头 012
\n 换行(LF),将当前位置移到下一行开头 010
\r 回车(CR),将当前位置移到本行开头 013

3.1 整型

C++中可以用以下方式表示整型,区别在于所占内存空间不同

数据类型 占用空间 取值范围
short(短整型) 2字节 -215~215-1
int(整型) 4字节 -231~231-1
long(长整型) windows为4字节;Linux 32位4字节,64位8字节 -231~231-1
long long(长长整型) 8字节 -263~263-1

3.2 浮点型(小数)

浮点型分为以下两种:

数据类型 占用空间 取值范围
float(单精度) 4字节 7位有效数字
double(双精度) 8字节 15~16位有效数字
  • 科学计数法
    举例:
    整数:3e1表示3*10^1,也就是30
    小数:3e-1表示3*10^-1,也就是0.3

3.3 字符型

表示单个字符的数据类型,只占一个字节。

  • 语法:char ch = 'a'
  • 注意:
    • 字符需要用单引号括起。
    • 且单引号中只能有一个字符。
    • 计算机真正存放的不是字符,是ASCII码。

3.4 字符串

表示一串字符,可以有两种表示方式。

  • C语言中常用方式(数组):char 变量名[] = "abcde"
    示例:

    int main(){
    	char str[] = "Hello world!";
    	cout<<str<<endl;
    	return 0;
    }
    
    • 注意:
      1. 字符串内容要用单引号括起来。
      2. 变量名后必须加中括号表示数组。
  • 当前标准方式:string 变量名 = "abcde"
    示例:

    #include <string>
    int main(){
    	string str = "Hello World!";
    	cout<<str<<endl;
    	return 0;
    }
    
    • 注意:
      1. 使用string需要引入头文件:#include <string>

3.5 布尔类型

代表"true(1)"或者"false(0)",表示逻辑。

  • 所占内存:1字节。
  • 本质上1代表真,0代表假。
  • 使用cin输入时,非0表示真,0表示假,0~1之间的小数视为0。

3. 运算符

包括四则运算,取余等方法。

  • 四则运算注意事项

    • 除法符号为"/"注意不要和反斜杠"\"混淆。
    • 除法运算时,两个整数(这里指类型)相除,结果依然是整数,小数部分消除(不是四舍五入)。
    • 0为除数时程序崩溃
  • 取模运算

    • 符号为"%"
    • 取模运算作用是获取两数相除所得余数。
    • 取模运算本质上也是除法的一种,除数不可为0。
    • 小数不可以进行取模运算
  • 递增和递减

    • 两者的功能类似,都是让变量加、减1
    • 前置递增/递减为先加1,后运算;后置递增/递减为先运算,后加1.
  • 赋值运算符

    • 包括=+=-=*=/=%=
      示例:
      int main(){
      	int a=1;
      	a=3;
      	//此时a=3;
      	a+=2;
      	//此时a=5
      	a-=3;
      	//此时a=2
      	a*=2;
      	//此时a=4
      	a/=2;
      	//此时a=2
      	a%=1;
      	//此时a=0
      	cout<<a<<endl;
      	return 0;
      }
      
  • 比较运算符

  • 包括==>=<=!=><

  • 逻辑运算符

    • 包括非!、与&&、或||
  • 三目运算符

    • 用法:表达式1 ? 表达式2 : 表达式3
    • 含义:如果表达式1成立,则返回表达式2的运行结果,否则返回表达式3的运行结果。
      示例:
    int main(){
    	int a=1,b=10,c=0;
    	//用法一
    	c = (a > b ? a : b);  //括号能提高三目运算的优先级防止运行出错
    	//将a和b中值较大的赋值给c
    	
    	//用法二
    	(a > b ? a : b) = 999;
    	//把999赋给a和b中较大的变量
    	return 0;
    }
    

4. 程序流程结构

4.1 顺序结构

就是从头到尾顺序执行,没啥可记的。

4.2 选择结构

判断选择,可以实现跳过或者分支。

  • if语句
    用法一:if(条件){满足条件执行的代码块}

    • 注意:
      1. 注意不要加入多余的分号。
    • 示例:
    int main(){
    	int score;
    	cout<<"Please input your score:";
    	cin>>score;
    	if (score>=600){
    		cout<<"Good!";
    	}
    	return 0;
    }
    

    用法二:if(条件){满足条件执行的代码块}else{不满足时执行的代码块}

    • 注意:
      1. else为可选分支,删除后和用法一相同。
      2. 注意不要加入多余的分号。
    int main(){
    	int score;
    	cout<<"Please input your score:";
    	cin>>score;
    	if (score>=600){
    		cout<<"Good!";
    	}else{
    		cout<<"Bad!";
    	}
    	return 0;
    }
    

    用法三:if(条件1){满足条件执行的代码块}else if(条件2){不满足条件1但满足条件2时执行的代码块}
    -。

    1. elseelse if 为可选分支.
    2. else if可并列多次使用
    int main(){
    	int score;
    	cout<<"Please input your score:";
    	cin>>score;
    	if (score>=600){
    		cout<<"Good!";
    	}
    	else if(score>=400){
    		cout<<"Bad!";
    	}
    	else{
    		cout<<"So Bad!";
    	}
    	return 0;
    }
    

    用法四:if语句的嵌套,我认为没啥高级的,所以不记了。

  • switch语句

    • 用法:在示例中演示
    • 意义:可以轻松实现多分支
      示例:
    int main(){
    	int level;
    	cin>>level;
    	switch(level){
    	case 1:
    		cout<<"Good";
    		break;
    	case 2:
    		cout<<"Normal";
    		break;
    	case 3;
    		cout<<"Bad";
    		break;
    	default :
    		cout<<"非法输入!请输入1~3之间的整数。";
    		break;
    	}
    	return 0;
    }
    
    • 注意:
      1. 需要使用break跳出分支。
      2. 缺点是无法使用区间视线分支。

4.3 循环结构

循环执行代码块。

4.3.1 while语句

条件满足时不断循环执行指定代码块,否则跳出循环。

  • 用法:while(条件){条件为真时循环执行的代码块}

  • 注意:

    1. 可以使用break跳出循环。
  • 示例:

    int main(){
    	int a=0;
    	while(a<10){
    		a++;
    		cout<<a;
    	}
    	return 0;
    }
    

4.3.2 do...while语句

  • 用法:do{代码块}while(条件);

  • 注意:

    1. 基本注意事项和while相同。
  • 示例:

    int main(){
    	int a=0;
       do{
           a++;
         cout<<a<<endl;
       }
       while(a<10);
       return 0;
    }
    

4.3.3 for循环语句

  • 用法:for(起始表达式;条件表达式;末尾表达式){循环代码块}

  • 注意:可以使用break跳出循环。

  • 示例:

    int main(){
        for(int i=1;i<10;i++){
            cout<<i<<endl;
        }
        return 0;
    }
    

4.4 跳转语句

用于跳出或者移动当前结构中的运行位置。

4.4.1 break语句

  • 可以出现在switch语句中,用于跳出分支。
  • 可以出现在循环语句中,用于跳出循环。
  • 在位于嵌套循环结构时,用于跳出当前所在层的循环。

4.4.2 continue语句

  • 作用:在循环语句中跳过余下尚未执行的语句,直接进入下一次循环。

  • 示例:

    int main(){
        for (int i=1;i<=10;i++)
        {
            cout<<i<<endl;
            continue;
            cout<<"这段不被输出\n";
        }
        return 0;
    }
    

4.4.3 goto语句

  • 作用:可以跳转到任意标记的位置。

  • 示例:

    int main(){
        for(int i=1;i<=10;i++){
            cout<<"这是第一句话\n";
            cout<<"这是第二句话\n";
            goto flag;
            cout<<"这句话我们不要了\n";
            flag:
            cout<<"这是第三句话\n";
        }
        return 0;
    }
    

5. 数组

数组就是一个集合,里边存放了一组相同类型的数据。

  • 特点
    1. 数组中每个元素都是相同的数据类型。
    2. 数组是由连续的内存位置组成的。

5.1 一维数组

  • 一维数组的定义方式:

    1. 数据类型 数组名[数组长度];
    2. 数据类型 数组名 [数组长度]={值1,值2,...,值n};
    3. 数据类型 数组名[]={值1,值2,...,值n};
  • 访问格式:array [0]

  • 注意事项:

    1. 访问时下标从0开始。
  • 示例:

    int main(){
        int arr[5]={1,2,3,4};//只初始化了前四个,第五个值默认初始化为0
        for(int i=0;i<=4;i++)
        {
            cout<<arr[i]<<endl;
        }
        arr[4]=5; //这是对数组中未初始化的第5个值赋值
        cout<<arr[0];
        return 0;
    }
    
  • 补充:

    • 数组名的用途:
      1. 可以统计数组或数组中元素所占内存空间。(使用sizeof(数组名/数组名[])函数)
      2. 可以获取数组在内存中的首地址。(cout<<array;
    • 数组名为常量,不可直接赋值。
  • 一维数组的倒置示例:

    int main(){
        int arr [5]={1,2,3,4,5};//创建一个数组
        int temp,a,b;
        a=0;b=sizeof(arr)/sizeof (arr[0])-1;//b为通过计算得出的数组中元素数量减1
        while(a<b){
            temp=arr[a];
            arr[a]=arr[b];
            arr[b]=temp;
            a++;b--;
        }
        b=sizeof(arr)/sizeof (arr[0]);//为了节省内存,将b重置为数组元素个数
        for(int i = 1;i<=b;i++){    //循环b次,依次输出数组中每个元素的值
            cout<<arr[i-1]<<endl;
        }
        return 0;
    }
    
  • 一维数组的顺序排列示例(冒泡排序):

    int main(){
        int arr[5]={1,5,2,3,4};
        for (int i = 0;i < 5;i++){
            for(int j = 0;j<(5-i-1);j++){
                if (arr[j]>arr[j+1]){
                int temp;
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
                }
            }
        }
    
        for (int q = 1; q<=5;q++){
            cout<<arr[q-1]<<endl;
        }
        return 0;
    }
    

5.2 二维数组

  • 定义方式:

    1. 数据类型 数组名 [行数][列数]={{数值1,数值2...},{数值n,数值n+1...}};
    2. 数据类型 数组名 [行数][列数];
    3. 数据类型 数组名 [行数][列数]={数据1,数据2,数据3,数据4};
    4. 数据类型 数组名 [][列数]={数据1,数据2,数据3,数据4};
    • 示例:

      int main(){
          //这是创建二维数组最直观的形式
          int arr[2][3]={
              {1,2,3},
              {4,5,6}
          };
          //使用for循环嵌套遍历输出二位数组中每个元素
          for (int i=0;i<2;i++){
              for (int j=0;j<3;j++){
                  cout<<arr[i][j]<<" ";
              }
              cout<<endl;
          }
          return 0;
      }
      
  • 二维数组名的用途

    1. 可以统计数组、数组中一行或数组中元素所占内存空间。(使用sizeof(数组名/数组名[]/数组名[][])
    2. 可以获取数组在内存中的首地址。(cout<<array;
  • 注意:

    1. 为了程序的可读性,我们一般使用前两种定义方式。
    2. 第三种定义方式会自动分出行列。
    3. 第四种必须指定列数,行数会依据数据数量进行自动分配。

6. 函数

函数就是一个程序块,可以方便的进行调用,能很好的减少代码量,一个较大的程序往往分成好多模块,每个模块实现特定功能。

6.1函数的定义

  • 函数的定义示例:

    返回值类型 函数名(形参)
    {
        程序代码块;
        retuen 返回值表达式;
    }
    
  • 注意:

    1. 必须返回一个正确的返回值类型。
    2. 若不需要返回值可以声明void函数。

6.2 函数的调用

  • 语法:函数名(参数)
  • 形式参数也叫形参,是一个形式,调用的是使用函数时传递的实参
  • 形参的值在函数中发生变化不会影响到实参。

6.3 函数的声明

  • 语法返回值类型 函数名(形参)

  • 注意:

    • 在main函数前声明函数防止程序运行时无法正常调用函数。
    • 可以有多次声明,但是只能有一次定义
  • 示例:

    int max(int num1,int num2); //函数max的声明
    int main(){
        cout<<max(100,101)<<endl;
        return 0;
    }
    int max(int num1,int num2){   //函数的定义
        return num1 > num2 ? num1:num2;
    } 
    //函数定义在main函数后需要在main函数前声明。
    

6.4 函数的分文件编写

为了防止单文件形势下代码量过大。

  • 要素:

    1. 一个自定义的头文件(.h)
    2. 源文件(.cpp)
    3. 函数的声明写在头文件中
    4. 函数的定义写在源文件中
  • 示例:

    • 文件结构:

    • 代码示例:

      • main.cpp

        #include <iostream>
        #include "max.h"
        
        using namespace std;
        
        int main(){
            cout<<max(100,101)<<endl;
            return 0;
        }
        
      • max.h

        #include <iostream>
        using namespace std;
        
        int max(int num1,int num2);
        
      • max.cpp

        #include "max.h"
        
        int max(int num1,int num2){
            return num1 > num2 ? num1:num2;
        }
        

        输出结果:100

6.5 函数的默认值

  • 语法:返回值类型 函数名(参数名=默认值);

  • 注意:

    • 如果某个位置开始有默认参数,那么从该位置往后都应该有默认参数。
    • 声明和实现只能有一个设置默认参数,不允许重定义默认参数。
  • 示例:

    void print(int a=10,int b=20,int c=30){ //给所有选项都设置了默认参数
        cout<<a+b+c<<endl; 
    }
    int main()
    {
        print(1,2,3);//调用函数是传递参数
        //输出6
        print();//调用函数时不传递参数,使用默认参数
        //输出60
        return 0;
    }
    

6.6 函数的占位参数

  • 语法:返回值类型 函数名 (数据类型);

  • 示例:

    void print(int = 10){ //只有数据类型,没有变量名就是占位参数
        cout<<"Hello World!";
    }
    int main(){
        print(); //因为占位参数具有默认值,所以此处无需传递,否则必须传递一个相应类型的参数
    }
    

6.7 函数的重载

6.7.1 概述

  • 意义:函数名可以相同,提高函数复用性。

  • 条件:

    • 同一作用域下。
    • 函数名称相同。
    • 函数参数名参数个数参数顺序不同。
  • 注意:函数的返回值不可用作函数重载的条件。

  • 示例:

    void print(){
        cout<<"print()函数被调用\n";
    }
    void print(int a){
        cout<<"print(int a)函数被调用\n";
    }
    int main()
    {
        print();//print()函数被调用
        print(1);//print(int a)函数被调用
        //其他例如参数名,参数个数,参数顺序不同 同理
        return 0;
    }
    

6.7.2 函数重载的细节问题

  • 常量引用

    • 示例:

      void print(int& a){
          cout<<"print()函数被调用\n";//如果传入数字1,则为int& a = 1 不合法
      }
      void print(const int& a){ //相当于const int& a = 1 合法
          cout<<"print(int a)函数被调用\n";
      }
      int main()
      {
          int a=1;
          print(a);
          print(1);
          return 0;
      }
      
  • 引入默认值导致的二义性

    • 示例:

      void print(int a){
          cout<<"print()函数被调用\n";
      }
      
      void print(int a,int b=1){
          cout<<"print(int a,int b=1)函数被调用\n";
      }
      int main()
      {
          print(1);//这个会报错,因为产生了二义性
          print(1,1);//会调用print(int a,int b=1)函数
          return 0;
      }
      

7. 指针

可以通过指针间接访问内存地址。

  • 注意:
    • 内存编号从0开始记录,一般使用十六进制数字保存
    • 可以利用指针变量保存地址
    • 不管什么指针,在32位系统下占用4字节,64位占用8字节。

7.1 指针的定义

  • 语法:数据类型 * 指针变量名

7.2 指针的使用

  • 让指针记录一个地址:

    • 语法:指针变量名 = &变量名

    • 注意:

      • &为取址符,可以获取当前内存地址。
  • 指针指向函数:

    • 语法:返回值 (*指针名)(参数列表);
  • 指针的使用:

    • 通过解引用影响指针指向内存区域所储存的值。

    • 示例:

    int main(){
        int a = 10;
        int * p;   //定义一个指针p
        p=&a;  //将变量a的地址赋给指针p
        //int * p = &a;   //这个方式可以将定义和赋值写在一起
        *p=1000;  //使用解引用影响指针p指向的内存区域,也就是变量a
        cout<<a<<endl;
        cout<<*p<<endl;		//通过输出展示指针所产生的影响
        return 0;
    }
    

7.3 空指针

  • 用途:给指针变量初始化。
  • 特点:空指针指向的内存区域无权访问。
  • 定义一个空指针:int * p = NULL

7.4 野指针

  • 定义:指向一块未申请的内存区域。
  • 特点:
    • 指向的内存区域通常无法读取或修改。
    • 一旦尝试读取或修改,则会报错。

7.5 const修饰指针

  • 三种方式:

    • const修饰指针:常量指针
      • 用法:const int * p = NULL
      • 作用:指针所指向的内存地址中的值为常量,不可更改;但是指针所指的地址可以更改。
    • const修饰常量:指针常量
      • 用法:int * const p = NULL
      • 作用:指针本身为常量,指向的内存地址不可更改,但是其值可以更改。
    • const同时修饰指针和常量
      • 用法:const int * const p=NULL
      • 作用:指针所指的内存地址不可更改,值也不可更改。

7.6 指针和数组

用指针操作数组。

  • 示例:

    int main(){
        int arr[5]={1,2,3,4,5};
        int * p=arr; //将指针指向数组在内存中的首地址
        for (int i=0;i<5;i++){
            cout<<*p<<endl; //输出指针p指向的值
            p++; //每次循环将指针p向后偏移4字节,实现指针在数组中的遍历
        }
        return 0;
    }
    

7.7 指针和函数

利用指针作为函数的参数可以修改实参的值。

  • 示例:

    void swap(int *p1,int *p2){  //声明一个函数用来交换两个变量的值,形参为两个指针
        //这部分直接影响了指针所指向的内存空间,也就是main函数中a,b两个变量的值
        int temp=*p1;
        *p1=*p2;
        *p2=temp;
    }
    int main(){
        int a=1,b=2;
        cout<<"a="<<a<<"  b="<<b<<endl;
        swap(&a,&b);  //引用函数,实参为两个变量的地址
        cout<<"a="<<a<<"  b="<<b<<endl;
        return 0;
    }
    

# 指针、函数、数组的搭配示例

利用冒泡循环对数组排序。

int bubbleSort(int * arr,int len){  //使用函数封装冒泡循环的算法
    for (int i = 0;i<len;i++){
        for(int j=0;j<len-i-1;j++){
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}
int main(){
    int arr []={1,5,3,2,7,8,3,5,2};
    int len=sizeof(arr)/sizeof (arr[0]); //获取数组的元素数量
    bubbleSort(arr,len);  //调用函数,第一个实参为arr数组的内存地址
    for(int i = 0;i<len;i++){
        cout<<arr[i]<<endl;
    }
}

8. 结构体

允许用户创建自定义数据类型,储存不同的数据类型。

8.1 定义和使用

  • 语法:struck 结构体名 { 结构体成员列表 };

  • 创建变量方式:

    • struck 结构体名 变量名 = {成员1;成员2;...}
    • struck 结构体名 变量名
    • 定义结构体时顺便创建变量
  • 使用变量的属性

    • 格式:变量名.属性
  • 示例:

    struct student //定义结构体(全局),struct关键字不可省略
    {
        string name;
        int age;
        int score;
    }s3; //此处s3为使用方法三创建的结构体变量
    
    int main(){
        //方法一
        struct student s1={"Maicss",19 , 650 } ;      //struct关键字可以省略
        cout<<"name:"<<s1.name<<"\tage:"<<s1.age<<"\tscore:"<<s1.score<<endl;
    
        //方法二
        struct student s2;   //struct关键字可以省略
        s2.name="qian";
        s2.age=18;
        s2.score=600;
        cout<<"name:"<<s2.name<<"\tage:"<<s2.age<<"\tscore:"<<s2.score<<endl;
    
        //方法三
        //创建结构体变量在定义结构体之后
        s3.name="son";
        s3.age=1;
        s3.score=700;
        cout<<"name:"<<s3.name<<"\tage:"<<s3.age<<"\tscore:"<<s3.score<<endl;
        return 0;
    }
    

8.2 结构体数组

  • 作用:将自定义的结构体放入数组中方便维护。

  • 语法:struck 结构体名 数组名[成员数] = { { } , { } , { } }

  • 示例:

    struct student {  //定义一个结构体
        string name;
        int age;
        int score;
    };
    int main()
    {
        //创建一个结构体数组
        struct student stuarr[3]{
        {"Maicss",19,100},
        {"Max",20,99},
        {"Pig",10,30}
        };
        
        //给结构体数组中第三个成员的score修改为98
        stuarr[2].score =98;
    
        //遍历输出结构体数组所有成员属性
        for (int i=0 ;i<3;i++){
            cout<<"name:"<<stuarr[i].name<<"\tage:"<<stuarr[i].age<<"\tscore:"<<stuarr[i].score<<endl;
        }
        return 0;
    }
    

8.3 结构体指针

  • 作用:通过指针访问结构体中的成员。

  • 利用操作符->可以通过结构体指针访问结构体属性。

  • 示例:

    struct student {  //定义一个结构体
        string name;
        int age;
        int score;
    };
    int main()
    {
        //创建一个结构体数组
        student s{"Maicss",19,100};
    
        //创建一个结构体指针
        student * p = &s;
    
       //通过指针读取结构体变量属性
        cout<<"name:"<<p->name<<"\tage:"<<p->age<<"\tscore:"<<p->score<<endl;
        return 0;
    }
    

8.4 结构体嵌套

  • 作用:让一个结构体成为另一个结构体的成员。

  • 示例:

    struct student {  //定义一个结构体
        string name;
        int age;
        int score;
    };
    struct teacher { //定义另一个结构体
        string name;
        int id;
        int age;
        student std;
    };
    int main()
    {
        //创建一个结构体变量
        student std1 {"max",18,100};
        //创建另一个结构体变量
        teacher thr1 {"maicss",197835,23,std1};
    
        //创建一个结构体指针
        teacher * p = &thr1;
    
        //修改老师maicss的学生max的年龄为19
        thr1.std.age=19;
        
       //通过指针读取结构体变量属性
        cout<<"name:"<<p->name
               <<"\tID:"<<p->id
               <<"\tage:"<<p->age
               <<"\tstudent:"<<p->stds.name  //读取嵌套在teacher结构体中的student的属性
            	 <<"\tstudentAge:"<<p->stds.age  //查看更改后的学生年龄
               <<endl;
        return 0;
    }
    

8.5 将结构体作为函数参数传递

  • 值传递

    • 直接在函数参数中传递结构体变量。
    • 特点:在函数内对参数值(结构体属性)的修改不会影响实参。
  • 指针传递

    • 在函数参数中传递结构体指针。
    • 特点:对值(结构体属性)的修改会影响到实参。
  • const 保护

    • 用const修饰指针,防止在函数中无意影响到函数实参。
  • 示例:

    struct student {  //定义一个结构体
        string name;
        int age;
        int score;
    };
    void print1(student a){ //结构体在函数参数中通过值传递
        cout<<"name:"<<a.name<<" age:"<<a.age<<" score:"<<a.score<<endl;
    }
    void print2(student * p){ //结构体在函数参数中通过指针传递
        p->age=100; //通过指针修改结构体属性的值可以影响到实参
        cout<<"name:"<<p->name<<" age:"<<p->age<<" score:"<<p->score<<endl;
    }
    int main()
    {
        //创建一个结构体变量
        student std1 {"max",18,100};
    
        //创建一个结构体指针
        student * p =&std1;
    
        //调用函数进行输出
        print1(std1); //值传递
        print2(&std1);//指针传递
        cout<<"name:"<<std1.name<<" age:"<<std1.age<<" score:"<<std1.score<<endl; //验证print2函数的修改
        return 0;
    }
    
    

9. 联系人管理系统实例

一个完整的联系人管理系统

10 程序的内存模型

10.1 内存分区模型

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

10.2 分区意义

  • 不同区域存放的数据赋予不同的生命周期,更强大的灵活的编程。

10.3 程序运行前

程序编译后,生成exe可执行程序,未执行该程序前分为两个区域。

  • 代码区:
    • 存放CPU执行的机器指令。
    • 代码区是共享的,共享的目的是对于频繁被执行的程序,只需要在内存中有一份代码即可。
  • 全局区:
    • 全局变量和静态变量存放在此。
    • 全局区也包含了常量区,字符串常量和其他非局部常量也存放在此。
    • 该区域的数据在程序结束后由操作系统释放。

10.4 程序运行后

  • 栈区

    • 由编译器自动分配和释放,存放函数的参数值,局部变量等。

    • 注意:不要返回栈区的地址,栈区开辟的数据由编译器自动释放。

    • 栈区的数据在函数执行完后自动释放。

    • 示例:

      int* integer(){
          int a=1;
          return &a; //返回局部变量a的内存地址
      }
      int main()
      {
          int * p=integer(); //将指针p指向局部变量a的地址
          cout <<*p<< endl;  //第一次解引用p
          //这里之所以会输出a是因为编译器为程序保留了一次内存
          cout <<*p<< endl;//第二次解引用p
          //编译器不再为程序保留,所以不再是原来的数值
          return 0;
      }
      
  • 堆区

    • 由程序员分配和释放,若程序员不释放,程序结束时由系统回收。

    • 使用new在堆区开辟内存。

      • 语法:new 数据类型
      • new创建的数据会返回该数据类型对应的指针。
    • 使用delect释放内存。

      • 语法:delect 指针
      • 释放后不能继续访问。
  • 为了防止出现野指针,在堆区内存空间被释放时要将指向该内存的指针指向NULL

    • 示例:
      int main()
      {
          int * p = new int(10); //使用new开辟一块内存储存整数10并将地址给指针p
          int * p2 = new int[10]; //创建一个数组
          cout<<*p<<endl;//解引用指针p结果为10
          //赋值部分省略
      delete p;//释放内存
          delete[] p2;//释放数组
      }
      

11. C++中的引用

引用的本质是指针常量。

11.1 引用的基本使用

  • 作用:给变量起别名。

  • 语法:&别名=原名

  • 注意事项:

    • 引用必须要初始化。
    • 引用一旦初始化就不可以更改。

11.2 引用作函数参数

  • 作用:就像指针一样,可以影响到实参。

  • 示例:

    //创建一个交换函数
    void swap(int &a,int &b){ //使用引用传递参数
      int temp;
        temp=a;
        a=b;
        b=temp;
    }
    int main()
    {
        int a,b;
        a=0;b=1;
        swap(a,b);
        cout<<a<<"\n"<<b<<endl;
    }
    

    11.2 引用作函数的返回值

    • 作用:可以让函数的调用作为左值。

    • 示例:

      //创建一个函数
      int& num(){
          static int a=10; //创建静态变量,储存在全局区中
          return a;
      }
      int main()
      {
          int& ref=num(); // 给num函数中的a搞一个引用
          num()=1000;
          cout<<ref<<endl; //验证将函数调用作为左值是否有效
          return 0;
      }
      
      

11.3 常量引用

  • 作用:可以用来修饰形参,防止实参被影响。

  • 示例:

    void change(const int& a){ //使用const修饰形参
        //此处不可修改a的值
        cout<<a;
    }
    int main()
    {
        int a=1;
        change(a);
        return 0;
    }
    

12. 类和对象

C++面向对象的三大特性:封装、继承、多态

万物皆对象、对象上有其属性和行为。

12.1 封装

12.1.1 封装的意义

  • 封装是c++面向对象三大特征之一

  • 封装的意义:

    • 将属性和行为作为一个整体来表现实物。
    • 将属性和行为加以权限控制。
  • 示例:

    #include <iostream>
    using namespace std;
    
    #define Pi 3.1415926 //定义一个宏常量Pi
    
    class circle{ //创建一个circle类
    public:  //定义公有部分
        int r;  //定义一个半径属性r
        double circle_C(){  //定义一个成员函数,计算周长
            return 2*r*Pi;
        }
        void set_r(double set_r){
            r=set_r;
        }
        
    };
    int main()
    {
        circle yuan; //通过circle类实例化一个对象
        yuan.r=10; //给对象的公有属性r赋值
        cout << yuan.circle_C() << endl; //通过成员函数输出周长
        yuan.set_r(5);
        cout << yuan.circle_C() << endl; //通过成员函数输出周长验证修改
        return 0;
    }
    

12.1.2 访问权限控制

  • 总共有三个权限

    名称 意义 特点
    public 公共权限 类内和类外都可以访问
    protected 保护权限 类内可以访问,类外不可以访问,子可以访问父的保护内容
    private 私有权限 类内可以访问,类外不可以访问,子不可访问父的私有内容
  • classstruct的区别:

    • class默认是私有权限,struct默认是公有权限。

12.1.3 成员属性私有化

  • 优点:

    • 对成员属性私有化可以自己控制读写权限。
    • 对于读写权限,可以检测数据的有效性。
  • 示例:

    #include <iostream>
    using namespace std;
    
    class human{
    public:
        void setName(string set_name){ //定义一个用来设置姓名的成员函数
            name=set_name;
        }
        string getName(){  //定义一个获取姓名的成员函数
            return name;
        }
        void setAge(int set_age){  //定义一个用来设置年龄的成员函数
            if (set_age<0 || set_age>150){  //使用if语句判断所给值是否合法
                cout<<"非法数据!";
            }else{
                age=set_age;
            }
        }
        int getAge(){  //定义一个用来获取年龄的成员函数
            return age;
        }
        void setLover(string set_lover){ //定义一个用来设置爱人的成员函数
            lover=set_lover;
        }
    private:  //私有属性的定义
        string name;
        int age;
        string lover;
    };
    int main()
    {
        human maicss; //实例化一个对象
        //使用成员函数设置相关属性
        maicss.setName("Maicss");
        maicss.setAge(18);
        maicss.setLover("qian");
        //使用成员函数获取相关私有函数的值在
        cout<<"name:"<<maicss.getName()<<" age:"<<maicss.getAge()<<endl;
        return 0;
    }
    

12.2 对象的初始化和清理

12.2.1 构造函数和析构函数

  • 对象的初始化清理是两个重要的问题。

    • 一个对象或者变量没有初始化状态,其使用后果是未知的。
    • 使用完一个对象或者变量,没有及时的清理,也会造成一定的安全问题。
  • 注意:

    • 构造函数和析构函数可以解决上述问题,由编译器自动调用,完成对象的初始化和清理工作。对象的初始化和清理是必须要做的事情。因此不必要提供构造和析构函数,编辑器会提供,但是编译器提供的构造函数和析构函数是空实现
    • 一个空对象所占用的内存为1字节,因为对象必须要有一个首地址。
  • 作用:

    • 构造函数:主要用在创建对象时给对象的成员属性赋值,由编译器自动调用。
    • 析构函数:主要用于对象销毁前的自动调用,负责清理工作。
  • 语法:

    • 构造函数:类名(){}

      1. 构造函数,没有返回值,也不用写void。
      2. 函数名称和类名相同。
      3. 构造函数可以有参数,因此可以发生重载。
      4. 程序在调用对象的时候自动调用构造函数,并且只会调用一次,无需手动调用。
    • 析构函数:~类名(){}

      1. 析构函数,没有返回值,也不用写void。
      2. 函数名称和类名相同,在名称前加上~
      3. 析构函数不可以有参数,因此无法发生重载。
      4. 程序在对象销毁前自动调用析构函数,并且只会调用一次,无需手动调用。
    1. 手动释放在堆区申请的空间要用delete语句。
  • 示例:

    class human{
    public: //为了保证构造函数和析构函数能被全局调用,所以需要设置为public权限
        human(){ //创建一个构造函数
            cout<<"human的构造函数被调用\n";
        }
        ~human(){ //创建一个析构函数
            cout<<"human的析构函数被调用\n";
        }
    
    };
    void hum(){ //函数中实例化一个对象,函数运行结束后对象被销毁
        human m;
    }
    int main()
    {
        human maicss;//创建对象同时运行构造函数
        hum(); //调用hum函数来创建对象,同时运行构造函数
        //hum函数运行结束时对象m被销毁,同时运行析构函数
        return 0;//mian函数返回0,程序结束前会运行析构函数
    }
    

12.2.2 构造函数的分类以及调用

  • 两种分类方式:

    • 按参数分为:有参构造和无参构造
    • 按类型分为:普通构造和拷贝构造
      • 拷贝构造函数是用来将一个对象的所有属性拷贝到新对象中。
  • 三种调用方式:

    • 括号法
    • 显示法
    • 隐式转换法
  • 注意事项:

    • 使用默认构造函数时,不要用(),否则会被认为是函数定义。
    • 不要利用拷贝构造函数初始化匿名对象,编译器会认为是参数对象的声明。
  • 示例(有点长):

    class human{
    public:
        human(){
            cout<<"human的无参(默认)构造函数被调用\n";
        }
        human(int a){
            age=a;
            cout<<"human的有参构造函数被调用\n";
        }
        human(const human &p){ //const的意义是不允许在构造函数中修改传入对象的属性,只读。
            age=p.age;
            cout<<"human的拷贝构造函数被调用\n";
        }
        ~human(){
            cout<<"human的析构函数被调用\n";
        }
        int age;
    
    };
    void hum1(){  //括号法调用
        human m1;   //无参构造
        human m2(10);  //有参构造
        human m3(m1);  //拷贝构造
    }
    void hum2(){  //显示法
        human m1;  //无参构造
        human m2=human(10);  //有参构造
        human m3=human(m1);  //拷贝构造
    }
    void hum3(){  //隐式转换法
        human m1;  //无参构造
        human m2=10;  //有参构造
        human m3=m2;  //拷贝构造
    }
    int main()
    {
        hum1();
        hum2();
        hum3();
        return 0;
    }
    

12.2.3 拷贝构造函数的调用时机

C++中拷贝构造函数的调用时机通常由三种情况:

  • 使用一个创建完毕的对象来初始化一个新的对象。
  • 以值传递的方式给函数的参数传值
  • 以值方式返回局部对象

12.2.4 构造函数的调用规则

默认情况下,C++编译器至少给一个类添加三个函数:

  1. 默认构造函数(无参,函数体为空)
  2. 默认析构函数(无参,函数体为空)
  3. 默认拷贝构造函数,对其属性值进行拷贝。

构造函数调用规则:

  • 如果用户自定义有构造函数,编译器不再提供默认无参构造函数,但是会提供默认拷贝构造。
  • 如果用户定义拷贝构造函数,编译器不再提供其他构造函数。
  • 总结:写了有参必须写无参,写了拷贝就得有参无参都写上。

12.2.5 深拷贝与浅拷贝

  • 定义:

    • 浅拷贝:简单的赋值操作。如果是用编译器提供的拷贝函数会利用浅拷贝。
    • 深拷贝:在堆区重新申请一块内存空间,进行拷贝操作。
  • 注意:

    • 浅拷贝可能导致堆区内存重复释放。
  • 示例(浅拷贝):

    class person{
    public:
        person(){
            cout<<"无参构造函数被调用\n";
        }
        person(int age,int height){
            m_height=new int (height); //在堆区申请一块内存区域用来存放height
            m_age=age;
            cout<<"有参构造函数被调用\n";
        }
        ~person(){
            if(m_height!=NULL){
                 delete m_height; //释放m_height指向的内存区域
            //析构函数会被执行两次,因为两个对象在man()函数结束后被销毁,但是由于浅拷贝将指针拷贝给第二个对象,因此两个对象的m_height指针指向了堆区的同一块内存区域,这块内存区域释放两次,会报错。
            
                 m_height=NULL;  //将指针指向NULL,防止野指针的出现。
            }
            cout<<"析构函数被调用\n";
        }
    private:
        int m_age;
        int * m_height; //创建一个int指针指向有参构造申请的内存区域
    };
    void man(){
        person one(16,160);
        person two(one);//浅拷贝
    }
    int main()
    {
        man();
        cout << "Hello World!" << endl;
        return 0;
    }
    
  • 示例(深拷贝):

    class person{
    public:
        person(){
            cout<<"无参构造函数被调用\n";
        }
        person(int age,int height){
            m_height=new int (height); //在堆区申请一块内存区域用来存放height
            m_age=age;
            cout<<"有参构造函数被调用\n";
        }
        person(const person &p){
            m_age=p.m_age;
            m_height=new int (*p.m_height);//在堆区重新申请一块内存实现深拷贝
        }
        ~person(){
            if(m_height!=NULL){
                 delete m_height; //释放m_height指向的内存,此时不会出现多次释放同一内存空间的问题
                 m_height=NULL;  //将指针指向NULL,防止野指针的出现。
            }
            cout<<"析构函数被调用\n";
        }
    
        int m_age;
        int * m_height; //创建一个int指针指向有参构造申请的内存区域
    };
    void man(){
        person one(16,160);
        person two(one);//由于定义了拷贝函数,所以此处会通过定义实现深拷贝
        cout<<one.m_age<<" "<<*one.m_height<<endl;
        cout<<two.m_age<<" "<<*two.m_height<<endl;
    }
    int main()
    {
        man();
        cout << "Hello World!" << endl;
        return 0;
    }
    

12.2.6 初始化列表

  • 作用:初始化列表语法可以用来初始化对象属性。

  • 语法:构造函数():属性1(值1),属性2(值2), ...

  • 示例:

    class person{
    public:
        person(int a,int b):age(a),height(b){}
        int age;
        int height;
    };
    void man(){
        person one(18,180);
        cout<<"age:"<<one.age<<" height:"<<one.height<<endl;
    }
    int main()
    {
        man();
        return 0;
    }
    

12.2.7 类对象作为类成员

  • 定义:一个类声明的对象成为另一个类的属性成员。

  • 例如:

    class A{}
    class B{
        A a;
    }
    
  • 注意:

    • 构造时先构造作为属性成员的对象(A)再构造对象本身(B)。
    • 析构时先析构对象本身(B)再析构各个属性成员(A)。

12.2.8 静态成员

静态成员可以看作属于类的作用域,被所有对象公用。

静态成员变量和静态成员函数都有权限控制。

  • 静态成员变量

    • 作用:所有成员公用一个成员变量。

    • 语法:static 数据类型 变量名

    • 注意:

      • 静态成员变量要在类内声明,类外初始化。
      • 在编译阶段会分配内存
    • 示例:

      class human{
      public:
          static int age;//在类内的声明
      };
      int human::age=100;//在类外的初始化
      int main()
      {
          human a; 
          cout<<a.age<<endl;
          human b;
          b.age=18;//使用对象b给静态变量重新赋值
          //也可以通过类名操作成员变量
          human::age=18;
          cout<<a.age<<endl;//此时对象a的age值也会随b变成18
          return 0;
      }
      
  • 静态成员函数

    • 作用:所有成员公用一个成员函数。属于类的作用域。

    • 语法:static 函数返回值类型 函数名();

    • 注意:静态成员函数属于类的作用域,只能操作静态成员变量。

    • 示例:

      class human{
      public:
          static void func(){
              age=1;
          }
          static int age;//在类内的声明
      };
      int human::age=100;//在类外的初始化
      int main()
      {
          human a;
          cout<<a.age<<endl;
          human b;
          //访问静态成员函数,下面两种方式效果完全相同
          b.func();//通过对象访问
          human::func();//通过类的作用域访问
          
          cout<<a.age<<endl;
          return 0;
      }
      

12.3 C++对象模型和this指针

12.3.1 成员变量和成员函数分开储存

  • 非静态成员变量属于类的对象
  • 静态成员变量不属于类的对象。
  • 非静态成员函数不属于类的对象。
  • 静态成员函数不属于类的对象。

12.3.2 this指针概念

  • 作用:this指针指向被调用的成员函数所属的对象。

  • 特点:

    • 隐含在每一个非静态成员函数内的一种特殊指针。
    • this指针不需要定义,直接用即可。
  • 使用场景:

    • 当形参名和成员变量名相同时,可以用this指针区分。
    • 在类的非静态成员函数中返回对象本身,可以用return *this
  • 示例:

    class human{
    public:
        void c_age(int age){
            this->age=age;//用this指针表示成员变量
        }
        human& addage(human &p){ //函数返回值要用引用的方式返回,否则会创建新对象
            this->age+=p.age;
            return *this;
        }
        int age;
    };
    void func(){
        human maicss;
        human p1;
        p1.age=10;
        maicss.c_age(18);
        maicss.addage(p1).addage(p1).addage(p1); //链式编程思想
        cout<<"maicss的年龄是:"<<maicss.age<<endl;
    }
    int main()
    {
        func();
        return 0;
    }
    
    

12.3.3 空指针调用成员函数

空指针可以调用成员,但是为了防止崩溃,要避免访问成员变量。

class human{
public:
    void printname(){
       cout<<"name is maicss\n";
    }
    void printage(){
        if (this==NULL){//防止程序崩溃进行的保险措施
            return ;
        }
        cout<<"age is "<<this->age<<endl;
    }
    int age;
};
void func(){
    human * maicss=NULL;
    maicss->printname();//使用空指针访问成员函数
    maicss->printage();//使用空指针在成员函数中访问成员变量

}
int main()
{
    func();
    return 0;
}

12.3.4 const修饰成员函数

常函数

  • 成员函数后加const,我们称这个函数为常函数。
  • 常函数内不可以修改成员属性。
  • 成员属性加关键字mutable后,在常函数中依然可以修改。

常对象

  • 声明对象前加const称该对象为常对象。
  • 常对象只能调用常函数。

示例

class human{
public:
    human(){}//新建一个无参构造函数,为了创建常对象
    void func() const{
       //age=18; //由于成员函数末尾加了const,所以函数体内不允许修改成员变量
        height=180; //由于成员变量前加了mutable关键字,所以该变量可以在函数中修改
    }
    void func2(){}
    int age;
    mutable int height;
};
int main()
{
    
    human maicss;
    const human maicss2;
    //maicss2.func2(); //由于是常对象,所以只能调用常函数。也只能修改带有mutable关键字的成员变量
    maicss.func();
    return 0;
}

12.4 友元

  • 作用:让一个函数或类,访问另一个类中的私有成员。

  • 关键字:friend

  • 三种实现方式:

    • 全局函数作友元
    • 类作友元
    • 成员函数作友元
  • 示例:

    class room; //声明类
    class goodgay2{
    public:
        goodgay2();
        void visit();
        room * m_room; //创建一个指针
    };
    class goodgay{
    public:
        goodgay(); //声明构造函数
        void visit(); //声明成员函数用于访问room的私有成员
        room * m_room; //创建一个指针
    };
    
    class room{
        friend void text();  //将全局函数作为友元
        friend class goodgay;  //将另一个类作为友元
        friend void goodgay2::visit();
    public:
        string sittingroom="客厅";
    private:
        string bedroom="卧室";
    };
    
    goodgay::goodgay(){  //类外定义构造函数
        m_room=new room; //在构造函数中于堆区创建一个对象
    }
    goodgay2::goodgay2(){
        m_room=new room;
    }
    void goodgay::visit(){   //类外定义成员函数
        cout<<"b在访问:"<<m_room->bedroom<<endl;
        cout<<"b在访问:"<<m_room->sittingroom<<endl;//访问room的私有成员
    };
    void goodgay2::visit(){
        cout<<"c在访问:"<<m_room->bedroom<<endl;//访问room的私有成员
    }
    void text(){
        room a;
        cout<<"a访问了:"<<a.bedroom<<endl;
        goodgay b;
        b.visit(); //通过访问visit成员函数访问room的私有成员
        goodgay2 c;
        c.visit();
    }
    
    int main()
    {
        text();
        return 0;
    }
    

12.5 运算符的重载

12.5.1 加号运算符的重载

  • 方式:

    • 使用成员函数重载
    • 使用全局函数重载
  • 示例:

    //使用成员函数重载
    class Person{
    public:
        int age;
        int height;
    public:
        Person operator+(Person &p); //使用成员函数对加号的重载
    };
    Person Person::operator+(Person &p){//定义重载函数
        Person temp;
        temp.age=this->age+p.age;
        temp.height=this->height+p.height;
        return temp;
    }
    int main(){
        Person p1;
        Person p2;
        p1.age=10;
        p2.age=18;
        p1.height=159;
        p2.height=180;
        Person p3=p1+p2;
        cout<<"P3的年龄为:"<<p3.age<<" P3的身高为:"<<p3.height<<endl;
        return 0;
    }
    
    //使用全局函数重载
    class Person{
    public:
        int age;
        int height;
    };
    Person operator+(Person &p1,Person &p2){ //使用成员函数对加号的重载
        Person temp;
        temp.age=p1.age+p2.age;
        temp.height=p1.height+p2.height; 
        return temp;
    }
    int main(){
        Person p1;
        Person p2;
        p1.age=10;
        p2.age=18;
        p1.height=159;
        p2.height=180;
        Person p3=p1+p2;
        cout<<"P3的年龄为:"<<p3.age<<" P3的身高为:"<<p3.height<<endl;
        return 0;
    }
    

12.6 继承

继承使面向对象三大特性之一

定义某些了类时,下一级别的成员拥有上一级别的共性,还有自己的特性。

使用继承可以尽量减少代码

  • 用法:class A : public B;

  • 说明:上述A为子类(派生类),B为父类(基类)。

  • 示例:

    class base{ //创建一个基类
    public:
        int age;
        string name;
    };
    class human : public base{ //创建一个以base为基类的派生类
    public:
        int score;
    };
    class dog : public base{//另一个以base为基类的派生类
    public:
        human master;
    };
    void test1(){ //对派生类中属性的访问示例
        human maicss;
        dog dazhuang;
        dazhuang.age=4;
        maicss.age=20;
        dazhuang.name="DAZ";
        maicss.name="Maicss";
        dazhuang.master=maicss;
        maicss.score=100;
    }
    int main()
    {
        void test1();
        return 0;
    }
    
  • 注意:

    • 经过测试,若定义基类时关键字改为private,那么所继承的所有属性全为私有属性;若为public,则正常继承。(这是依我自己理解的)
    • 被定义为protected的成员变量为保护权限,此时子类可以访问这种成员变量,但是如果是private则无法访问,这也是两者的唯一区别。

13. 文件操作

使用文件操作需要包含头文件<fstream>

文件类型分为两种:

  1. 以ASCII码形式储存的文本数据。
  2. 二进制文件形式储存的,用户一般读不懂。

操作文件三大类:

  1. ofstream 写文件
  2. ifstream 读文件
  3. fstream 读写文件

13.1文本文件

13.1.1写文件的基本操作

写文件的基本步骤:

//1.包含头文件
#include <fstream>
//2.创建流对象
ofstream ofs;
//3.打开文件
ofs.open("文件路径",打开方式);
//4.写数据
ofs<<"文本文件";
//5.关闭文件
ofs.close();
打开方式 解释
ios::in 为读文件而打开文件
ios::out 为写文件而打开文件
ios::ate 初始位置:文件尾
ios::app 追加方式写文件
ios::trunc 如果文件存在,先删除再创建
ios::binary 二进制方式

文件打开方式配合使用需要|符号

示例:

#include <iostream>
#include <fstream> //包含文件流头文件

using namespace std;

int main()
{
    std::ofstream ofs; //创建一个ofstream类对象,实现写文件
    ofs.open("text.txt",ios::out); //打开文件
    ofs<<"你好世界"; //写到文件
    return 0;
}

13.1.2读文件的基本操作

写文件的基本步骤:

//包含头文件
#include <fstream>
//创建流对象
std::ifstream ifs;
//打开文件
ifs.open("文件路径",打开方式);
if (!ifs.is_open()){
    cout<<"文件打开失败"<<endl;
    return ;
}
//读入文件
    //第一种方式
    char text1[1024]={0};
    while (ifs>>text1) {
        cout<<text1<<endl;
    }
    //第二种方式
    char text2[1024]={0};
    while (ifs.getline(text2,sizeof(text2))){
        cout<<text2<<endl;
    }
    //第三种方式
    string text3;
    while (getline(ifs,text3)) {
        cout<<text3<<endl;
    }
    //第四种方式
    char text4;
    while ((text4=ifs.get())!=EOF){
        cout<<text4;
    }
//关闭文件
close

14. C++中的STL

STL是为了提高软件代码的复用性而产生的一种标准模板库

14.1 STL的基本概念

  • STL(Standard Template Library,标准模板库)
  • STL从广义上分为:容器(container)、算法(algorithm)、迭代器(iterator)
  • 容器算法之间通过迭代器无缝连接。
  • STL几乎所有代码都采用了模板类或模板函数。

14.2 vector容器的基本使用

  • 容器:vector

  • 算法:for_each

  • 迭代器:vector<int>::iterator

  • 示例:

    #include <iostream>
    using namespace std;
    #include <vector>//使用容器必须引入头文件
    void print(int i) {//第三种遍历方法要用到
    	cout << i << endl;
    }
    int main() {
    	vector<int> v;
    	v.push_back(1);//使用尾插添加元素
    	v.push_back(2);
    	v.push_back(3);
    	v.push_back(4);
        
        //遍历容器的第一种方法
    	vector<int>::iterator head = v.begin();//begin()会返回指向容器中第一个元素的指针
    	vector<int>::iterator tail = v.end();//end()会返回指向容器中最后一个元素的下一个位置的指针
    	while (head != tail)
    	{
    		cout << *head << endl;
    		head++;
    	}
        //遍历容器的第二种方法(是第一种方式的简化)
        for (vector<int>::iterator h = v.begin(); h != v.end(); h++) {
    		cout << *h << endl;
    	}
        //遍历容器的第三种方法(使用标准算法库中的for_each)
        for_each(v.begin(),v.end(),print);
        
    	getchar();
    	return 0;
    }
    

14.3 string容器的基操

  • stringchar *的区别
    • 本质上两者区别不大,前者是后者的封装,可以管理字符串。
  • 构造函数
    • string(); 无参构造,创建一个空的字符串。
    • string(const char* s); 使用字符串s进行初始化。
    • string(const string& str);使用字符串str初始化。
    • string(int n,char c);使用n个字符c初始化。

# 其他内容

随机数生成

  • rand()函数
    • 用法:rand()%10可以生成0~9的随机数。
    • 置随机数种子:srand((unsigned int)time(NULL))(需要#include <ctime>)

内存

  • 获取内存地址

    • 数组的首地址可以直接使用数组的名字。
    • 或者使用取址符“&”。
  • 注意:

    • 0~255之间的内存是无法访问的。

静态变量

  • 在普通变量前加static为静态变量。
  • 静态变量储存在内存的全局区中。
posted @ 2021-04-04 20:03  Maicss  阅读(154)  评论(0编辑  收藏  举报