C++语法根底（数据类型、运算符、程序流程构造、数组、函数、指针、构造体）

1 C++ 初识

1.1 规范代码格局

#include<iostream>
using namespace std;

int main() {

    cout << "Hello world" << endl;

    system("pause");

    return 0;
}

1.2 正文

作用：在代码中加一些阐明和解释，不便本人或其余程序员程序员浏览代码

两种格局

1. 单行正文：// 形容信息

   • 通常放在一行代码的上方，或者一条语句的开端，== 对该行代码阐明 ==

2. 多行正文：/* 形容信息 */

   • 通常放在一段代码的上方，== 对该段代码做整体阐明 ==

提醒：编译器在编译代码时，会疏忽正文的内容

1.3 变量

作用：给一段指定的内存空间起名，不便操作这段内存

语法 ： 数据类型 变量名 = 初始值;

// 变量的定义
// 语法：数据类型 变量名 = 初始值
int a = 10;

留神：C++ 在创立变量时，必须给变量一个初始值，否则会报错

1.4 常量

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

C++ 定义常量两种形式

1. \#define 宏常量：#define 常量名 常量值

   • == 通常在文件上方定义 ==，示意一个常量
   • 永远不可批改

2. const润饰的变量 const 数据类型 常量名 = 常量值

   • == 通常在变量定义前加关键字 const==，润饰该变量为常量，不可批改
   • 能够通过指针援用批改

//1、宏常量 永远不可批改
#define day 7
int main() {
    //2、const 润饰变量    能够通过指针援用批改
    const int month = 12;
    
    system("pause");
    return 0;
}

1.5 关键字

作用：关键字是 C ++ 中事后保留的单词（标识符）

• 在定义变量或者常量名字的时候，不要用关键字

C++ 关键字如下：

提醒：在给变量或者常量起名称时候，不要用 C ++ 得关键字，否则会产生歧义。

1.6 标识符命名规定

作用：C++ 规定给标识符（变量、常量）命名时，有一套本人的规定

• 标识符不能是关键字
• 标识符只能由字母、数字、下划线组成
• 第一个字符必须为字母或下划线
• 标识符中字母辨别大小写

倡议：给标识符命名时，争取做到见名知意的成果，不便本人和别人的浏览

2 数据类型

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

2.1 整型

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

C++ 中可能示意整型的类型有以下几种形式，区别在于所占内存空间不同：

2.2 sizeof 关键字

作用：利用 sizeof 关键字能够 == 统计数据类型所占内存大小 ==

语法： sizeof(数据类型 / 变量)

cout << "short 类型所占内存空间为：" << sizeof(short) << endl;
    cout << "int 类型所占内存空间为：" << sizeof(int) << endl;
    cout << "long 类型所占内存空间为：" << sizeof(long) << endl;

整型论断：==short < int <= long <= long long==

2.3 实型（浮点型）

作用：用于 == 示意小数 ==

浮点型变量分为两种：

1. 单精度 float
2. 双精度 double
3. 默认状况下，输入一个小数，只会显示 6 位有效数字

两者的 区别 在于示意的有效数字范畴不同。

2.4 字符型 ———- 1 个字节

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

语法：char ch = 'a';——- 用单引号创立字符，单引号内只能有一个字符

留神 1：在显示字符型变量时，用单引号将字符括起来，不要用双引号

留神 2：单引号内只能有一个字符，不能够是字符串

• C 和 C ++ 中字符型变量只占用 == 1 个字节 ==。
• 字符型变量并不是把字符自身放到内存中存储，而是将对应的 ASCII 编码放入到存储单元

ASCII 码表格：

ASCII 码大抵由以下 两局部组 成：

• ASCII 非打印控制字符：ASCII 表上的数字 0-31 调配给了控制字符，用于管制像打印机等一些外围设备。
• ASCII 打印字符：数字 32-126 调配给了能在键盘上找到的字符，当查看或打印文档时就会呈现。

2.5 转义字符

作用：用于示意一些 == 不能显示进去的 ASCII 字符 ==

现阶段咱们罕用的转义字符有： \n \\ \t

\t— 八个空格

2.6 字符串型

作用：用于示意一串字符

两种格调

1. C 格调字符串：char 变量名[] = "字符串值"

   char str1[] = "hello world";

留神：C 格调的字符串要用双引号括起来

1. C++ 格调字符串：string 变量名 = "字符串值"

   string str = "hello world";

   留神：C++ 格调字符串，须要退出头文件 ==#include\<string>==

2.7 布尔类型 bool———1 个字节

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

bool 类型只有两个值：

• true — 真（实质是 1）
• false — 假（实质是 0）

bool 类型占 == 1 个字节 == 大小

2.8 数据的输出

作用：用于从键盘获取数据

关键字：cin

语法： cin >> 变量

    int a = 0;
    cin >> a;
    cout << a << endl;

3 运算符

作用：用于执行代码的运算

本章咱们次要解说以下几类运算符：

3.1 算术运算符

作用：用于解决四则运算

算术运算符包含以下符号：

在除法运算中，除数不能为 0

只有整型变量能够进行取模运算

前置递增先对变量进行 ++，再计算表达式，后置递增相同

3.2 赋值运算符

作用：用于将表达式的值赋给变量

赋值运算符包含以下几个符号：

3.3 比拟运算符

作用：用于表达式的比拟，并返回一个真值或假值

比拟运算符有以下符号：

留神：C 和 C ++ 语言的比拟运算中，==“真”用数字“1”来示意，“假”用数字“0”来示意。==

3.4 逻辑运算符

作用：用于依据表达式的值返回真值或假值

逻辑运算符有以下符号：

4 程序流程构造

C/C++ 反对最根本的三种程序运行构造：== 程序构造、抉择构造、循环构造 ==

• 程序构造：程序按程序执行，不产生跳转
• 抉择构造：根据条件是否满足，有抉择的执行相应性能

• 4 程序流程构造

  C/C++ 反对最根本的三种程序运行构造：== 程序构造、抉择构造、循环构造 ==

  • 程序构造：程序按程序执行，不产生跳转
  • 抉择构造：根据条件是否满足，有抉择的执行相应性能
  • 循环构造：根据条件是否满足，循环屡次执行某段代码

4.1 抉择构造

4.1.1 if 语句

作用：执行满足条件的语句

if 语句的三种模式

• 单行格局 if 语句 if(条件){条件满足执行的语句} –if 条件表达式后不要加分号
• 多行格局 if 语句 if(条件){条件满足执行的语句}else{条件不满足执行的语句};
• 多条件的 if 语句 if(条件 1){条件 1 满足执行的语句}else if(条件 2){条件 2 满足执行的语句}... else{都不满足执行的语句}

4.1.2 三目运算符

作用： 通过三目运算符实现简略的判断

语法：表达式 1 ? 表达式 2：表达式 3

解释：

如果表达式 1 的值为真，执行表达式 2，并返回表达式 2 的后果；

如果表达式 1 的值为假，执行表达式 3，并返回表达式 3 的后果。

和 if 语句比拟，三目运算符长处是短小整洁，毛病是如果用嵌套，构造不清晰

4.1.3 switch 语句

作用：执行多条件分支语句

语法：

switch(表达式)
{
    case 后果 1：执行语句;break;
    case 后果 2：执行语句;break;
    ...
    default: 执行语句;break;
}

留神 1：switch 语句中表达式类型只能是整型或者字符型

留神 2：case 里如果没有 break，那么程序会始终向下执行

总结：与 if 语句比，对于多条件判断时，switch 的构造清晰，执行效率高，毛病是 switch 不能够判断区间

4.2 循环构造

4.2.1 while 循环语句

作用：满足循环条件，执行循环语句

语法： while(循环条件){循环语句}

解释：== 只有循环条件的后果为真，就执行循环语句 ==

在执行循环语句时候，程序必须提供跳出循环的进口，否则呈现死循环

4.2.2 do…while 循环语句

作用： 满足循环条件，执行循环语句

语法： do{循环语句} while(循环条件);

留神：与 while 的区别在于 ==do…while 会先执行一次循环语句 ==，再判断循环条件

与 while 循环区别在于，do…while 先执行一次循环语句，再判断循环条件

4.2.3 for 循环语句

作用： 满足循环条件，执行循环语句

语法： for(起始表达式; 条件表达式; 开端循环体) {循环语句;}

留神：for 循环中的表达式，要用分号进行分隔

总结：while , do…while, for 都是开发中罕用的循环语句，for 循环构造比拟清晰，比拟罕用

4.2.4 嵌套循环

作用： 在循环体中再嵌套一层循环，解决一些理论问题

例如咱们想在屏幕中打印如下图片，就须要利用嵌套循环

// 外层循环执行 1 次，内层循环执行 1 轮
for (int i = 0; i < 10; i++)
{for (int j = 0; j < 10; j++)
    {cout << "*" << " ";}
    cout << endl;
}

4.3 跳转语句

4.3.1 break 语句

作用: 用于跳出 == 抉择构造 == 或者 == 循环构造 ==

break 应用的机会：

• 呈现在 switch 条件语句中，作用是终止 case 并跳出 switch
• 呈现在循环语句中，作用是跳出以后的循环语句
• 呈现在嵌套循环中，跳出最近的内层循环语句

4.3.2 continue 语句

作用：在 == 循环语句 == 中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

留神：continue 并没有使整个循环终止，而 break 会跳出循环

4.3.3 goto 语句

作用：能够无条件跳转语句

语法： goto 标记;

解释：如果标记的名称存在，执行到 goto 语句时，会跳转到标记的地位

示例：

int main() {
    cout << "1" << endl;
    goto FLAG;
    cout << "2" << endl;
    FLAG:
    cout << "3" << endl;
    system("pause");
    return 0;
}

留神：在程序中不倡议应用 goto 语句，免得造成程序流程凌乱

5 数组

5.1 概述

所谓数组，就是一个汇合，外面寄存了雷同类型的数据元素

特点 1：数组中的个 == 数据元素都是 雷同的数据类型==

特点 2：数组是由 ==间断的内存== 地位组成的

5.2 一维数组

5.2.1 一维数组定义形式

一维数组定义的三种形式：

1. 数据类型 数组名[数组长度];
2. 数据类型 数组名[数组长度] = {值 1，值 2 ...};
3. 数据类型 数组名[] = { 值 1，值 2 ...};

总结 1：数组名的命名标准与变量名命名标准统一，不要和变量重名

总结 2：数组中下标是从 0 开始索引

5.2.2 一维数组数组名

一维数组名称的 用处：

1. 能够统计整个数组在内存中的长度
2. 能够获取数组在内存中的首地址

留神：数组名是常量，不能够赋值

总结 1：间接打印数组名，能够查看数组所占内存的首地址

总结 2：对数组名进行 sizeof，能够获取整个数组占内存空间的大小

5.2.3 冒泡排序

作用： 最罕用的排序算法，对数组内元素进行排序

1. 比拟相邻的元素。如果第一个比第二个大，就替换他们两个。
2. 对每一对相邻元素做同样的工作，执行结束后，找到第一个最大值。
3. 反复以上的步骤，每次比拟次数 -1，直到不须要比拟

5.3 二维数组

二维数组就是在一维数组上，多加一个维度。

5.3.1 二维数组定义形式

二维数组定义的四种形式：

1. 数据类型 数组名[行数][列数];
2. 数据类型 数组名[行数][列数] = {{数据 1，数据 2}，{数据 3，数据 4} };
3. 数据类型 数组名[行数][列数] = {数据 1，数据 2，数据 3，数据 4};
4. 数据类型 数组名[][ 列数] = {数据 1，数据 2，数据 3，数据 4};

倡议：以上 4 种定义形式，利用 == 第二种更加直观，进步代码的可读性 ==

总结：在定义二维数组时，如果初始化了数据，能够省略行数

5.3.2 二维数组数组名

• 查看二维数组所占内存空间 siziof(arr)
• 获取二维数组首地址

总结 1：二维数组名就是这个数组的首地址

总结 2：对二维数组名进行 sizeof 时，能够获取整个二维数组占用的内存空间大小

6 函数

6.1 概述

作用：将一段常常应用的代码封装起来，缩小反复代码

一个较大的程序，个别分为若干个程序块，每个模块实现特定的性能。

6.2 函数的定义

函数的定义个别次要有 5 个步骤：

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法：

返回值类型 函数名（参数列表）{
       函数体语句
       return 表达式
}

• 返回值类型：一个函数能够返回一个值。在函数定义中
• 函数名：给函数起个名称
• 参数列表：应用该函数时，传入的数据
• 函数体语句：花括号内的代码，函数内须要执行的语句
• return 表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

6.3 函数的调用

性能：应用定义好的函数

语法： 函数名（参数）

函数定义里小括号内称为形参，函数调用时传入的参数称为实参

6.4 值传递

• 所谓值传递，就是函数调用时实参将数值传入给形参
• 值传递时，== 如果形参产生，并不会影响实参 ==

总结：值传递时，形参是润饰不了实参的

6.5 函数的常见款式

常见的函数款式有 4 种

1. 无参无返
2. 有参无返
3. 无参有返
4. 有参有返

6.6 函数的申明

作用： 通知编译器函数名称及如何调用函数。函数的理论主体能够独自定义。

• 函数的 申明能够屡次 ，然而函数的 定义只能有一次

6.7 函数的分文件编写

作用：让代码构造更加清晰

函数分文件编写个别有 4 个步骤

1. 创立后缀名为.h 的头文件
2. 创立后缀名为.cpp 的源文件
3. 在头文件中写函数的申明
4. 在源文件中写函数的定义

7 指针

7.1 指针的基本概念

指针的作用： 能够通过指针间接拜访内存

• 内存编号是从 0 开始记录的，个别用十六进制数字示意
• 能够利用指针变量保留地址

7.2 指针变量的定义和应用

指针变量定义语法：数据类型 * 变量名；

指针变量和一般变量的区别

• 一般变量寄存的是数据, 指针变量寄存的是地址
• 指针变量能够通过 ” * “ 操作符，操作指针变量指向的内存空间，这个过程称为解援用

总结 1：咱们能够通过 & 符号 获取变量的地址

总结 2：利用指针能够记录地址

总结 3：对指针变量解援用，能够操作指针指向的内存

7.3 指针所占内存空间

发问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

答复：所有指针类型在 32 位操作系统下是 4 个字节,64 位操作系统下 8 个字节

7.4 空指针和野指针

空指针 ： 指针变量指向内存中编号为 0 的空间

// 指针变量 p 指向内存地址编号为 0 的空间
    int * p = NULL;

用处：初始化指针变量

留神：空指针指向的内存是不能够拜访的

野指针：指针变量指向非法的内存空间

// 指针变量 p 指向内存地址编号为 0x1100 的空间
    int * p = (int *)0x1100;

总结：空指针和野指针都不是咱们申请的空间，因而不要拜访。

7.5 const 润饰指针

const 润饰指针有三种状况

1. const 润饰指针 — 常量指针——- 地址能够扭转，值不能扭转
2. const 润饰常量 — 指针常量——- 地址不能扭转，值能够扭转
3. const 即润饰指针，又润饰常量—- 地址不能扭转，值不能扭转

技巧：看 const 右侧紧跟着的是指针还是常量, 是指针就是常量指 针，是常量就是指针常量

7.6 指针和数组

作用：利用指针拜访数组中元素

示例：

int main() {int arr[] = {1,2,3,4,5,6,7,8,9,10};
    int * p = arr;  // 指向数组的指针
    cout << "第一个元素：" << arr[0] << endl;
    cout << "指针拜访第一个元素：" << *p << endl;
    for (int i = 0; i < 10; i++)
    {
        // 利用指针遍历数组
        cout << *p << endl;
        p++;
    }
    system("pause");
    return 0;
}

p++

7.7 指针和函数

作用：利用指针作函数参数，能够批改实参的值

// 地址传递
void swap2(int * p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

总结：如果不想批改实参，就用值传递，如果想批改实参，就用地址传递

7.8 指针、数组、函数

案例形容：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

// 冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也能够写为 int arr[]
{for (int i = 0; i < len - 1; i++)
    {for (int j = 0; j < len - 1 - i; j++)
        {if (arr[j] > arr[j + 1])
            {int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
// 打印数组函数
void printArray(int arr[], int len)
{for (int i = 0; i < len; i++)
    {cout << arr[i] << endl;
    }
}
int main() {bubbleSort(arr, len);
    printArray(arr, len);
    system("pause");
    return 0;
}

总结：当数组名传入到函数作为参数时，被进化为指向首元素的指针

8 构造体

8.1 构造体基本概念

构造体属于用户 == 自定义的数据类型 ==，容许用户存储不同的数据类型

8.2 构造体定义和应用

语法：struct 构造体名 {构造体成员列表}；

通过构造体创立变量的形式有三种：

• struct 构造体名 变量名
• struct 构造体名 变量名 = {成员 1 值，成员 2 值 …}
• 定义构造体时顺便创立变量

总结 1：定义构造体时的关键字是 struct，不可省略

总结 2：创立构造体变量时，关键字 struct 能够省略

总结 3：构造体变量利用操作符 ”.” 拜访成员

8.3 构造体数组

作用：将自定义的构造体放入到数组中不便保护

语法： struct 构造体名 数组名[元素个数] = {{} , {} , ... {} }

8.4 构造体指针(对象指针也是一样的)—（->）

作用：通过指针拜访构造体中的成员

• 利用操作符 -> 能够通过构造体指针拜访构造体属性

8.5 构造体嵌套构造体

作用： 构造体中的成员能够是另一个构造体

例如：每个老师辅导一个学员，一个老师的构造体中，记录一个学生的构造体

总结：在构造体中能够定义另一个构造体作为成员，用来解决理论问题

8.6 构造体做函数参数

作用：将构造体作为参数向函数中传递

传递形式有两种：

• 值传递
• 地址传递

总结：如果不想批改主函数中的数据，用值传递，反之用地址传递

8.7 构造体中 const 应用场景

作用：用 const 来避免误操作 —-加了 const，就不能批改参数值

void printStudent(const student *stu) // 加 const 避免函数体中的误操作