c++笔记

最新推荐文章于 2024-09-27 11:26:03 发布

Morcool

最新推荐文章于 2024-09-27 11:26:03 发布

阅读量213

点赞数

文章标签： c++ 算法 java

本文链接：https://blog.csdn.net/Morcool/article/details/127939421

版权

第一阶段

第一章、基础语法

一、注释

1、单行注释

语法：//

2、多行注释

语法/* 信息 */

二、变量与常量

1、变量

定义语法：数据类型变量名 = 初始值
小型存储空间

2、常量

定义语法：#define 常量名常量值
或者：const 数据类型常量名 = 常量值

三、关键字

1、注意不要给变量起名为关键字

四、标识符起名规则

不能是关键字
只能由字母数字下划线组成
第一个字符不能是数字
大小写敏感

五、数据类型

1、整形

数据类型	占用空间	范围
short	2字节	(-2^15~215-1)
int	4字节	(-2^31~231-1)
long	windows、Linux(32位)为4字节，Linux(64位)为8字节	(-2^31~231-1)
long long	8字节	(-2^63~263-1)

2、sizeof关键字

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

3、实型

数据类型	占用空间	范围
float	4字节	7位有效数字
double	8字节	15~16位有效数字

4、字符型

语法：char ch='a';
只占一个字节
不能是字符串
存储变量的ASCII码值

5、转义字符

常用\n、\\、\t
换行，代表一个反斜杠，水平制表

6、字符串型

c风格：char 变量名[]="字符串值"
c++风格string 变量名="字符串值"

7、布尔类型

true为真，本质为1
false为假，本质为0
占1个字节大小

8、数据输入

cin>>变量;

9、运算符

+、-、*、/、%，加、减、乘、除、取余
++前置时先运算后赋值，后置时先赋值后运算，–同理
赋值运算符：+=、-=、*=、/=、%=
比较运算符：==、!=、>、<、>=、<=，结果分别是0与1
逻辑运算符：!、&&、||，非、与、或

第二章、程序流程结构

一、选择结构

1、if语句

单行语句、多行语句、多条件语句
单行语句语法：if(条件){条件满足时执行的语句}
多行：if(条件){条件满足时执行的语句}else{条件不满足时执行的语句}
多条件：if(条件1){条件1满足时执行的语句}else if(条件2){条件2满足时执行的语句}……else{都不满足时执行的语句}
嵌套：if(条件1){if(条件2){………}}

2、三目运算符

表达式1 ? 表达式2 : 表达式3
若1真，则执行2，若1为假，则执行3

3、switch语句

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

二、循环结构

1、while循环

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

2、do-while语句

do{循环语句} while(条件);
先执行一次循环语句然后再判断条件

3、for循环

语法for(起始表达式;条件表达式;末尾循环体){循环语句}
满足条件即执行循环语句

4、嵌套循环

在循环体中再嵌套一层循环

5、break、continue、goto

break作用为跳出选择结构或循环结构
continue作用：在循环语句中，跳过本次循环中余下尚未执行的语句，开始下一次循环
goto语法：goto 标记
若标记存在，执行到goto时，会跳转到标记位置
标记定义语法：名称:

第三章、数组

一维数组

1、一维数组

特点1：数组中每个元素都是相同的数据类型
特点2：数组是由连续的内存位置组成的
定义方式：
数据类型数组名[数组长度];
数据类型数组名[长度]={值1，值2……};
数据类型数组名[]={值1，值2……};
数组的下标从0开始

2、数组名的用途

可以统计整个数组在内存中的长度
如sizeof(arr)
可以获取数组在内存中的首地址
如cout<<arr<<endl;
数组名是常量，不可进行赋值操作

3、冒泡排序

for(int i=0;i<元素个数-1;i++){
    for(int j=0;j<元素个数-i-1){
        if(arr[j]>arr[j+1]){
            int temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }
}

分外层循环与内层循环
外层个数：元素个数-1
内层个数：元素个数-当前轮数-1

二维数组

1、定义

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

2、数组名

查看二维数组所占内存空间
如sizeof(arr)
获取二维数组首地址
如cout<<arr<<endl;

第四章、函数

一、函数的定义

1、定义

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

二、函数的调用

1、功能

使用定义好的函数

2、语法

函数名(参数)

三、值传递

函数调用时实参将数值传入给形参
值传递时，如果形参发生改变，并不会影响实参

四、函数常见形式

1、无参无返

void test1()
{
	函数体
}

2、有参无返

void test2(int a)
{
	函数体
}

3、无参有返

int test3()
{
	函数体
	return表达式;
}

4、有参有返

int test4(int a)
{
	函数体
	return表达式;
}

五、函数的声明

告诉编译器函数名称及如何调用函数，函数的实际主题可以单独定义
函数的声明可以有多次，但是函数的定义只能有一次
语法：int 函数名(形参);

六、函数的分文件编写

作用：使代码结构更加清晰

步骤：

创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
注：两个文件的名字一样
在头文件中写函数的声明
在源文件中写函数的定义

第五章

一、指针

1、作用

可以通过指针间接访问内存
内存编号是从0开始记录，一般用16进制表示
可以用指针变量保存地址

2、定义

语法：数据类型 * 指针变量名，如int * p=&a;
p=&a，即记录a的地址

3、使用

*p找到要找的内存
可以对其修改与使用
若b=p则b保存的是地址
若b=*p则b保存的是变量值

4、占用内存

在32位操作系统占用4个字节，64位下占用8个字节

二、空指针与野指针

1、空指针

指针变量中指向编号为0的空间
用于初始化指针变量
空指针指向的内存不可访问
定义：如int * p = NULL;

2、野指针

指针变量指向非法的内存空间
定义：如int * p = (int *)0x1100;
会导致程序报错

三、const修饰指针

1、常量指针

定义：如const int * p = &a;
特点：指针的指向可以修改，指针指向的值不可以修改

2、指针常量

定义：如int * const p = &a;
特点：指针指向的值可以修改，指针的指向不可以修改

3、const既修饰指针又修饰常量

定义：如const int a * const p = &a;
指向的值与指向都不可以修改

四、指针与数组

1、利用指针来访问数组中的元素

如int * p = arr;

2、也可利用指针遍历数组

记得p要写一个p++

五、指针和函数

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

1、值传递

函数体内变量的值的变化不会影响函数体外部变量

2、地址传递

如
void swap(int *p1,int * p2)
{
    int temp= *p1;
    *p1=*p2;
    *p2=temp;
}
int a=10;
int b=20;
swap(&a,&b);

这样就可以在函数体内修改实参的值
互换了a与b的地址故函数外a与b的值被修改

第六章、引用

给变量起别名
###一、基本语法

数据类型 &别名 = 原名
如int &b = a
若修改b的值，那么a的值也会变化

二、注意事项

引用必须初始化
引用在初始化后，不可以改变
初始化为一个变量的别名后，不可再改为其他变量的别名

三、引用做函数参数

作用：函数传参时，可以利用引用让形参修饰实参
优点：可以简化指针修饰实参

实例

int myswap(int &a,int &b)
{
	int temp = a;
	a=b;
	b=temp;
}

这样在main函数中引用此函数，形参就会修饰实参了

swap中的a与b是别名，那么swap函数中对a与b的操作就是在对实参操作

四、引用函数做返回值

作用：引用可以作为函数返回值存在
注意：不要返回局部变量引用

实例

int& test01()
{
	int a=10;

	return a;
}
int main()
{
	int& ref=test01;

	cout<<ref<<endl;

	cout<<ref<<endl;
}

这样，第一次输出ref的值时是正常的a，因为编译器做了暂时的保留，而第二次输出则为乱码，因为a在test01中执行完操作就被释放了

用法：函数调用可以作为左值

实例

int& test02()
{
	static int a=10;
	return a;
}
int main()
{
	int& ref2=test02;

	cout<<ref2<<endl;

	test02 = 1000;//如果函数的返回值是引用，这个函数的调用可以作为左值进行赋值

	cout<<ref2<<endl;
}

有“static”那么a就是静态变量，只有在整个程序结束后才会被系统释放
第一个ref2输出为10，第二个ref2的输出为1000