c++笔记

C++

注释

作用：两种格式： 在代码中加一些说明和注释，方便自己或其他程序员阅读代码
1 . 单行注释:

//描述信息 

• 通常放在一行代码的上方，或者一条语句的末尾，对该代码进行说明

2 .多行注释：

/*描述信息*/

• 通常放在一段代码的上方，对该段代码进行整体说明

  提示：编译器在编译代码时，会忽略掉注释内容

  变量

  作用：给指定的内存空间起名，方便操作这段内存
  语法：

  数据类型 变量名=初始值
  

  常量

  作用：用于记录程序中不可更改的数据
  C++定义常量两种方式
  1 . #define宏常量：

  #define 常量名 常量值
  

• 通常在文件上定义，表示一个常量

2 .const修饰的变量

const 数据类型 常量名 = 常量值 

• 通常在变量前加关键字const，修饰该变量为常量，不可修改

关键字

**作用 **：关键字是C++中预先保留的关键字（标识符）

• 在定义变量的时候不要使用关键字

标识符命名规则

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

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

建议：给标识符命名时，争取做到见名知意的效果，方便自己和他人阅读

数据类型

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

整型

作用：整型变量表示的是整型类型的数据
C++中能够表示整形的类型有

1. short(短整型)：2字节

2. int（整形）：4字节

3. long（长整型）：8字节

4. long long（长长整型）：8字节

   sizeof关键字

   作用：利用sizeof关键字可以统计数据类型所占内存的大小
   语法：

   sizeof(数据类型/变量)
   

实型（浮点型）

作用：用于表示小数
浮点型分为两种：
1.单精度float ：四字节
2.双精度double ：八字节

字符型

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

char ch='a';

注意1：在显示字符型变量的时候，用单引号将字符括起来，不要用双引号

注意2：单引号内只能由一个字符，不可以是字符串

• C和C++中字符型变量只站一个字节

• 字符型变量并不只是把字符本身放到内存中储存，而是将对应的ASCII编码放到储存单元中

  转义字符

  作用：用于表示一些不能显示出来的ASCII字符
  现阶段我们常用的转义字符有

  \n \\ \t
  

  字符串型

  作用：用于表示一串字符
  两种风格：
  1.C风格字符串

  char 变量名[]="字符串值"
  

  注意：C风格的字符串要用双引号括起来

  2.C++风格的字符串：

  string 变量名=“字符串值”
  

  布尔类型bool

  作用布尔数据类型类型代表真或假的值
  bool类型只有两个值：

• true···真（本质是一）

• false···假（本质是0）
  bool类型占1个字节大小

  数据的输入

  作用：用于从键盘获取数据
  关键字：cin
  语法：

  cin>>变量
  

  运算符

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

  算术运算符

  作用：用于处理四则运算

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10+5	15
-	减	10-5	5
*	乘	10*5	50
/	除	10/5	2
%	取模	10%3	1
++	前置递增	a=2;b=++a	a=3;b=3
++	后置递增	a=2;b=a++	a=3;b=2
–	前置递减	a=2;b=–a	a=1;b=1
–	后置递减	a=2;b=a–	a=1;b=2

赋值运算符

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

运算符	术语	示例	结果
=	赋值	a=2;b=3	a=2;b=3;
+=	加等于	a=0;a+=2	a=2
-=	减等于	a=5;a-=3	a=2
*=	乘等于	a=2;a*=2	a=4
/=	除等于	a=4;a/=2	a=2
%=	模等于	a=3;a%=2	a=1

比较运算符

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

运算符	术语	示例	结果
==	相等于	4==3	0
！=	不等于	4！=3	1
<	小于	4<3	0
>	大于	4>3	1
<=	小于等于	4<=3	0
>=	大于等于	4>=1	1

逻辑运算符

作用：用于根据表达式的值返回真值和假值

运算符	术语	示例	结果
！	非	！a	如果a为假，则！a为真；如果a为真，则！a为假
&&	与	a&&b	如果a和b都为真，则结果为真，否则为假
||	或	a||b	如果a和b有一个为真，则结果为真，二者都为假时，结果都为假

程序流程结构

选择结构

if语句

作用：执行满足条件的语句
if语句的三种形式

• 单行格式if语句
• 多行格式if语句
• 多条件的if语句

1.单行格式if语句：

if（条件）
{
条件满足执行的语句
}

2.多行格式的语句：

if(条件)
{
    条件满足执行的语句;
}
else
{
    条件不满足执行的语句;
}

3.多条件的if语句：

if(条件)
{
条件1满足执行的语句;
}
else if(条件2)
{
条件满足执行的语句;
}
...
else
{
都不满足执行的语句;
}`

嵌套if语句：在if语句中，可以嵌套使用if语句，达到更精确的条件判断

三目运算符

作用：通过三目运算符实行简单的判断
语法：

表达式1?表达式2:表达式3

解释：
如果表达式1的值为真，执行表达式2，并返回表达式2的结果
如果表达式1的值为假，执行表达式3，并返回表达式3的结果

switch语句

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

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

循环结构

while循环语句

作用：满足循环条件，执行循环语句
语法：while(循环条件){循环语句}
解释：只要循环条件的结果为真，就执行循环语句

do…while循环语句

作用：满足循环条件，执行循环语句
语法：do{循环语句}while(循环条件)
注意：与while的区别在于do…while会先执行一次循环语句，在判断循环条件

for循环语句

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

for (起始表达式;条件表达式;末尾表达式)
      {
      循环语句;
      }

嵌套循环

作用：再循环语句中在嵌套一层循环，解决一些实际问题

跳转语句

break

作用：用于跳出选择结构或者循环结构
break使用的时机：

• 出现switch条件语句中，作用是终止case并跳出switch

• 出现在循环语句中，作用是跳出当前的循环语句

• 出现在嵌套语句中，跳出最近的内层嵌套循环语句

  continue

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

  goto

  作用：可以无条件跳转语句
  语法：

  goto 标记;
  

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

  数组

  所谓数组，就是一个集合，里面存放了相同类型的数据元素
  特点1：数组中每个数据元素都是相同的数据类型
  特点2：数组是由连续的内存位置组成的

  一维数组名的用途

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

  冒泡排序

  作用：最常见的排序算法，对数组内元素进行排序
  1.比较相邻的元素。如果第一个比第二个大，就交换他们两个
  2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值
  3.重复以上的步骤。每次比较次数-1，直到不需要比较

  二维数组

  二维数组定义的方式：
  1.数组类型 数组名[行数][列数]
  2.数组类型 数组名[行数][列数]={{数据1，数组2}，{数组3，数组4}}
  3.数组类型 数组名[][列数]={数据1，数据2，数据3，数据4}
  ###建议：以上四种定义，利用第二种更加直观，提高代码的可读性

  函数

  概述

  作用：将一段经常使用的代码封装起来，减少重复的代码
  一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能

  函数的定义

  函数的定义一般主要要有5个步骤：
  1.返回值类型
  2.函数名
  3.参数表列
  4.函数体与语句
  5.return 表达式
  语法：

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

  函数的调用

  功能：使用定义好的函数
  语法：

  函数名（参数）
  

  函数的值传递

• 所谓 值传递，就是函数调用时实参将数值传入形参

• 值传递时，如果形参发生变化，并不会影响实参

函数的常见样式

常见的函数样式有四种：
1.无参无返
2.有参无返
3.无参有返
4.有参有返

函数的声明

作用：告诉编译器函数名及如何调用函数。函数的实际主体可以单独定义

• 函数的声明可以多次，但是函数的定义只能有一次

函数的分文件编写

作用：让代码结构更加清晰
函数分文件编写一般有4个步骤

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

指针

指针的基本概念：

作用：可以通过指针访问内存

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

定义：

数据类型 *变量名;

让指针记录变量的地址

int a=10;
int*p;
p=&a;
cout<<"a的地址为："<<&a<<endl;
cout<<"指针p为"<<p<<endl;

可以通过解引用的方式来找到指针指向的方式，指针前假*代表解引用，找到指针指向的内存中的数据

int a=10;
int*p;
p=&a;
cout<<"a的地址为："<<&a<<endl;
cout<<"指针p为"<<p<<endl;
*p=1000;
cout<<"a="<<a<<endl;
cout<<"*p="<<*p<<endl;

空指针和野指针

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

用途：初始化指针变量

注意：空指针指向的内存是不可访问的

int main()
{
    int*p=NULL;
    return 0;
}

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

int main()
{
    int*p=(int*)0*1100;
    return 0;
}

在程序中，尽量避免出现野指针

常量指针：

const int*p=&a;

特点：指针的值可以修改，但是指针指向的值不可修改

指针常量：

int *const p=&a;

特点：指针的值不可以修改，但是指针指向的值可以修改

const即修饰指针又修饰常量

const int *const p=&a;

指针的值和指向都不可改

arr[]={};
int*p=arr;
cout<<""<<p;
cout<<""<<*p;
p++; //后移四个字节
cout<<"第二个元素"<<*p;    

利用指针做函数参数，可以修改实参的值（指针可以传递）

引用

作用：给变量起别名

语法：

数据类型 &别名=原名

int main()
{
    int a=10;
    int &b=a;
    return 0;
}

注意事项

• 引用必须初始化
• 引用在初始化后，不可以改变

int main()
{
    int a=10;
    int b=20;
    //int &c;//错误，引用必须初始化
    int &c=a;//一但初始化后，就不可以改变
    c=b;//这是赋值操作，不是更改引用
    return 0;
}

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

//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.引用传递
void mySwap03(int& a,int& b)//引用传递，形参会修饰实参
{
    int temp=a;
    a=b;
    b=temp;
}

引用函数做函数返回值

作用：引用是可以作为函数返回值存在的

注意：不要返回局部变量的引用

用法：函数调用作为左值

//返回值局部变量引用
int& test01()
{
    int a=10;//局部变量
    return a;
}
//做打印，第一次结果正确，是因为编译器做了保留
//第二次错误，是因为内存已经释放
//返回静态变量引用
int& test02()
{
    static int a=20;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
    return a;
}
int main()
{
    int &ref=test02()
}

引用的本质

**本质：**指针常量

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

常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

使用场景：用来修饰形参，防止误操作

viod showValue(const unt&v){
    cout<<v<<endl;
}
int main(){
    //int& ref=10;引用本身需要一个合法的内存空间，因此此行错误
    //加入const就可以了，编译器优化代码，int temp=0;const int& ref=temp;
    const int&ref=10;
    //ref=100;//加入const后不可以改变变量
    return 0；
}