C++基础

海风mask

已于 2023-05-16 11:30:45 修改

阅读量86

点赞数 1

分类专栏： C++ learn 文章标签： c++

于 2022-11-07 22:06:15 首次发布

本文链接：https://blog.csdn.net/CYK246/article/details/127732732

版权

C++ learn 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1、初识

1.1 基本框架

#include <iostream>
using namespace std;

int main() {
    system("pause");
    return 0;
}

1.2 注释

单行 //
多行 /* ... */

1.3 变量

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

1.4 常量

用于记录程序中不可更改的数据
定义
1、#define 宏常量： #define 常量名常量值
2、 const修饰的变量： const 数据类型常量名 = 常量值

1.5 关键字

关键字是C++中预先保留的单词（标识符）

1.6 标识符命名规则

见名知意 小驼峰

2、数据类型

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

2.1 整型

2.2 sizeof关键字

统计数据类型所占内存大小
sizeof( 数据类型 / 变量)

2.3 实型（浮点型）

单精度 float
双精度 double
两者的区别在于表示的有效数字范围不同

2.4 字符型

用于显示单个字符
char ch = 'a';
注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号
注意2：单引号内只能有一个字符，不可以是字符串
只占用1个字节
字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元

2.5 转义字符

用于表示一些不能显示出来的ASCII字符
常用的转义字符有： \n \\ \t （换行、反斜杠、水平制表）

2.6 字符串型

C风格字符串： char 变量名[] = "字符串值"
C++风格字符串： string 变量名 = "字符串值" 需要加入头文件#include<string>

2.7 布尔类型 bool

代表真或假的值
bool类型只有两个值：
- true --- 真（本质是1）
- false --- 假（本质是0）
bool类型占1个字节大小

2.8 数据输入输出

cin >> 变量
cout << ... << endl;

3 运算符

3.1 算术运算符

+ - * / % ++ -- （前置后置区别）
在除法运算中，除数不能为0
只有整型变量可以进行取模运算
前置递增先对变量进行++，再计算表达式，后置递增相反

3.2 赋值运算符

= += -= *= /= %=

3.3 比较运算符

== != >= <= > <

3.4 逻辑运算符

&& || ！

4 程序流程结构

4.1 选择结构

if语句
三目运算符：和if语句比较，三目运算符优点是短小整洁，缺点是如果用嵌套，结构不清晰
switch语句

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

注意1：switch语句中表达式类型只能是整型或者字符型
注意2：case里如果没有break，那么程序会一直向下执行
总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

4.2 循环结构

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

4.3 跳出语句

break
continue
goto：goto 标记;

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

5 数组

5.1 概述

数据元素都是相同的数据类型
连续的内存存储

5.2 一维数组

定义

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

一维数组名

可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址

cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;

cout << "数组首地址为： " << (int)arr << endl;
cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;

注意：数组名是常量，不可以赋值
总结1：直接打印数组名，可以查看数组所占内存的首地址
总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小

5.3 二维数组

定义

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

二维数组数组名

查看二维数组所占内存空间
获取二维数组首地址

cout << "二维数组大小： " << sizeof(arr) << endl;
cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;
cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
//地址
cout << "二维数组首地址：" << arr << endl;
cout << "二维数组第一行地址：" << arr[0] << endl;
cout << "二维数组第二行地址：" << arr[1] << endl;
cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;

6 函数

6.1 概述

将一段经常使用的代码封装起来，减少重复代码

6.2 定义

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

6.3 调用

函数名（参数）区别形参和实参

6.4 值传递

如果形参发生，并不会影响实参

6.5 函数常见样式

无参无返
有参无返
无参有返
有参有返

6.6 函数声明

告诉编译器函数名称及如何调用函数
函数的声明可以多次，但是函数的定义只能有一次

6.7 函数的分文件编写

创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义

7 指针

7.1 概述

间接访问内存
内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址

7.2 定义

数据类型 * 变量名；

//1、指针的定义
int a = 10; //定义整型变量a
//指针定义语法： 数据类型 * 变量名 ;
int * p;
//指针变量赋值
p = &a; //指针指向变量a的地址
cout << &a << endl; //打印数据a的地址
cout << p << endl; //打印指针变量p
//2、指针的使用
//通过*操作指针变量指向的内存
cout << "*p = " << *p << endl;

指针变量和普通变量的区别
- 普通变量存放的是数据,指针变量存放的是地址
- 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用
总结1：我们可以通过 & 符号获取变量的地址 int *p = &a;
总结2：利用指针可以记录地址
总结3：对指针变量解引用，可以操作指针指向的内存 *p;

7.3 指针所占内存空间

所有指针类型在32位操作系统下是4个字节

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的

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

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

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

总结：空指针和野指针都不是我们申请的空间，因此不要访问

7.5 const修饰指针

const修饰指针有三种情况

const修饰指针 --- 常量指针
const修饰常量 --- 指针常量
const即修饰指针，又修饰常量

//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
const int * p1 = &a;
p1 = &b; //正确
//*p1 = 100; 报错
//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
int * const p2 = &a;
//p2 = &b; //错误
*p2 = 100; //正确
//const既修饰指针又修饰常量
const int * const p3 = &a;
//p3 = &b; //错误
//*p3 = 100; //错误

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

7.6 指针和数组

利用指针访问数组中元素

int * p = arr; //指向数组的指针
cout << "第一个元素： " << arr[0] << endl;
cout << "指针访问第一个元素： " << *p << endl;
for (int i = 0; i < 10; i++)
{
    //利用指针遍历数组
    cout << *p << endl;
    p++;
}

7.7 指针和函数

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

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

int a = 10;
int b = 20;
swap1(a, b); // 值传递不会改变实参
swap2(&a, &b); //地址传递会改变实参

7.8 指针、数组、函数

void bubbleSort(int * arr, int len) //int * arr 也可以写为int arr[]
{
  ...
}
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
int len = sizeof(arr) / sizeof(int);
bubbleSort(arr, len);

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

8 结构体

8.1 概述

自定义的数据类型

8.2 定义和使用

struct 结构体名 { 结构体成员列表 }；
通过结构体创建变量的方式有三种：

struct 结构体名变量名
struct 结构体名变量名 = { 成员1值，成员2值...}
定义结构体时顺便创建变量

//结构体定义
struct student
{
    //成员列表
    string name; //姓名
    int age; //年龄
    int score; //分数
}stu3; //结构体变量创建方式3

//结构体变量创建方式1
struct student stu1; //struct 关键字可以省略
//结构体变量创建方式2
struct student stu2 = { "李四",19,60 };

总结1：定义结构体时的关键字是struct，不可省略
总结2：创建结构体变量时，关键字struct可以省略
总结3：结构体变量利用操作符 ''.'' 访问成员

8.3 结构体数组

struct 结构体名数组名[元素个数] = { {} , {} , ... {} }

//结构体数组
struct student arr[3]=
{
    {"张三",18,80 },
    {"李四",19,60 },
    {"王五",20,70 }
};

8.4 结构体指针

通过指针访问结构体中的成员
利用操作符 -> 可以通过结构体指针访问结构体属性

struct student * p = &stu;
p->score = 80; //指针通过 -> 操作符可以访问成员

8.5 结构体嵌套结构体

结构体中的成员可以是另一个结构体

8.6 结构体做函数参数

将结构体作为参数向函数中传递
传递方式有两种：值传递地址传递

//值传递
void printStudent(student stu)
{
    ...
}
//地址传递
void printStudent2(student *stu)
{
    ...
}
//值传递
printStudent(stu);
//地址传递
printStudent2(&stu);