C++基础_1

第一个C++程序：①创建项目，②创建文件，③编写代码，④运行程序
注释：单行注释：//，多行注释：/* */

hello world程序：

#include<iostream>
using namespace std;
int main() {
	cout << "hello world" << endl;
	system("pause");
	return 0;
}

变量：方便我们管理内存空间
变量创建的语法：数据类型 变量名=变量初始值
如int a=10;

常量：程序中不可更改的数据：
①#define 常量名 常量值（宏常量，一般在文件上方定义）
②const 数据类型 常量名=常量值

关键字（标识符）：指C++已经征用的字：if，do，return，int等
变量名命名规则：①不能是关键字
②只能由字母、数字、下划线组成
③第一个字符必须是字母或下划线
④字母区分大小写
建议：起名时最好能够见名知意

数据类型：给变量分配合适的内存空间
short短整型：2字节
int整型：4字节
long长整形：4字节
long long长长整型：8字节

sizeof：可以统计数据类型所占内存的大小
如：cout<<sizeof(int)<<endl;

实型（浮点数）：
①float，单精度，4字节，float f1=3.14f;
②double，双精度，8字节，double d1=3.14;
科学计数法：float f=3e2;

字符型：表示单个字母、字符的变量
char ch=‘a’;
字符需用’ '引起来，只能引一个字符
char占用1个字节
字符型变量是把对应的ASCII编码存放在计算机中，查看ASCII编码：
cout<<(int)ch<<endl;
ASCII编码：A->65，a->97

转义字符：用来表示一些不能显示出来的ASCII字符
\a，警报，ASCII码：007
\n，换行，ASCII码：010
\t，水平指标，ASCII码：009
\，反斜线“\”，ASCII码：092
\t有对齐效果：

cout<<"aaa\t"<<endl;
cout<<"aaaa\t"<<endl;

输出结果为（前面的字符串和\t共8个位置，aaa占3个，后面留5个）

字符串型：①char 变量名[]=“字符串值”，如char str[] = “hello world”;
②string 变量名=“字符串值”，如string str = “hello world”;

布尔数据类型：占用1个字节
true：1和非0的值（如100，q等）
false：0
创建变量bool flag = true;

数据的输入：cin>>变量;

运算符：

①算数运算符：+，-，*，/，%，++，–

int a = 10; int b = 3; a/b = 3//两整数相除仍是整数
int a = 10; int b = 0; a/b =//程序会崩
int a = 10; float b = 3; a/b=3.333333

两小数不可以做取模运算，整数与小数也不能取模
前置递增:++a，让变量先+1，再计算
后置递增:a++，让变量先计算，再+1
同理前置递减、后置递减

②赋值运算符：
=：a=2
+=:a=0; a+=2; 则a=2（a=a+2;）
同理-=，*=，/=，%=

③比较运算符：
==：判断是否相等，cout<<(4==3)<<endl;//则输出false
!=，<=，>=，<，>

④逻辑运算符：！非，&&与，||或

程序流程结构：顺序、选择、循环

选择结构

if语句
单行if：if(条件){执行}//if()后面不加;
多行if：if(){} else{}
多条件if：if(条件1){} else if(条件2){} else if(条件3){} else{}

三目运算符：表达式1？表达式2：表达式3;//表达式1对，执行2

switch语句：

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

switch语句结构清晰，执行效率高；但是判断时只能是整型或字符型，不可以是一个区间
一定要记得写break； 否则会一直向下执行完所有的case

循环结构

while循环语句：while(循环条件){循环语句}
一定要避免死循环

do while循环语句：do{循环语句} while(循环条件)
与while的区别：do while会先执行一次循环语句，再判断循环条件

for循环语句：for(起始表达式;条件表达式;末尾循环体){循环语句}
如for(int i=0;i<10;i++)//这三块都可以放在循环里面或外面，但是要保留;

嵌套循环：循环套循环

153获取个位：153%10
获取十位：153/10%10
获取百位：153/100

rand()%b+a; 生成a~a+b-1的随机数
但是这样生成的是伪随机，若想真正生成随机数，需添加随机数种子，即利用当前时间生成随机数，防止每次生成随机数都一样
srand((unsigned int)time(NULL))；并添加头文件：<ctime>

跳转语句

break语句：用于跳出选择结构或循环结构
①出现在switch条件语句中，作用是终止case并跳出switch
②出现在循环语句中，作用是跳出当前的循环语句
③出现在嵌套循环中，跳出内存循环

continue语句：跳过本次循环中余下尚未执行的语句，继续执行下次循环
continue可以筛选条件，如输出奇数

goto语句：可以无条件跳转语句
语法：goto 标记;

数组

一个集合，里面存放了相同类型的数据元素

一维数组

数据类型 数组名[数组长度];int arr[5];
数据类型 数组名[数组长度]={值1，值2…};int arr[5]={1,2,3,4,5};
数据类型 数组名[]=={值1，值2…};int arr[]={1,2,3,4,5};

数组arr[5]={1，2，3，4，5}; arr[0]=1; arr[4]=50;
下标是从0开始索引
初始arr[]的元素默认为0

数组名的用途：
①统计整个数组在内存中的长度。如sizeof(arr)，sizeof(arr[0])
数组长度计算：sizeof(arr)/sizeof(arr[0]);
②获取数组在内存中的首地址（数组中第一个元素的地址）。
cout<<arr<<endl;和cout<<&arr[0]<<endl;等价
数组名是常量，不可进行赋值操作

二维数组

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

行列都是从0开始索引的，如arr[0][0]
二维数组名用途：
①查看二维数组占内存空间
②获取二维数组的首地址
sizeof(arr)/sizeof(arr[0]):行数
sizeof(arr[0])/sizeof(arr[0][0]):列数

cout<<arr;//数组的首地址
cout<<arr[0];//数组第一行的首地址
cout<<arr[0][0];//输出第一个元素
cout<<&arr[0][0];//输出第一个元素的首地址

函数

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

①返回值类型 ②函数名 ③参数列表 ④函数体语句 ⑤return表达式
① ②(③)
{④ ⑤}
⑤与①相联系，若①是int，则⑤为return 0，1等等
③是传输数据的

函数调用：功能：使用定义好的函数
语法：函数名(参数); 如add(x,y);

值传递：即函数调用时实参将数值传入给形参
值传递时，若形参发生变化，不影响实参

函数常见样式

1.无参无返，void test()
2.有参无返，void test(int a)
3.无参有返，int test()
4.有参有返，int test(int a)

函数的声明

作用：告诉编译器函数名称及调用函数，函数的实际主体可以单独定义
函数的声明可以多次，但是函数的定义只能有一次
若无函数的声明，则子函数只能放前面，main函数放后面
如果想把main函数放前面，则需在main函数前进行子函数的声明
语法：数据类型 函数名(参数列表);如int quda(int a, int b);

函数分文件编写

作用：让代码结构更加清晰
步骤：
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在后文件中写函数的声明

#include<iostream>
using namespace std;
void swap(int a, int b);

4.在源文件中写函数的定义

#include"头文件.h"
函数定义

5.在main函数的文件中包含头文件

#include"头文件.h"
{主函数}

指针

指针的作用：通过指针间接访问内存
比如一个变量a=10;其存放在0x0000这个地址
而指针即存放这个变量的地址0x0000的变量，可通过地址访问变量
内存编号是从0开始记录的，一般是用十六进制数字表示

指针定义语法

数据类型*指针变量名
如int*p; int a=10;
让指针p记录变量a的地址：p=&a;

指针的使用

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

所以a=*p; a=*&a;
若*p=100; 则a=100;

指针所占用的内存空间

指针也是种数据类型，这种数据类型占的空间：
32位操作系统：4字节
64位操作系统：8字节
不管是int*还是double*都一样

空指针

指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的
如int* p = NULL; cout<<*p或*p=100;都是错的
若运行，则程序崩了，只要有*p都会崩
0~255之间的内存编号是系统占用的，因此不能访问

野指针

指针变量指向非法的内存空间
如int*p=(int*)0x1100; cout<<*p<<endl;则出错
0x1100是随便申请的内存空间，不能进行访问；在程序中，要尽量避免野指针

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

const修饰指针

①const修饰指针——常量指针
②const修饰常量——指针常量
③const既修饰指针，又修饰常量

常量指针

int a = 10;
int b = 20;
const int* p = &a;

const修饰指针——常量指针
特点：指针的指向可以修改p=&b;√
但指针指向的值不可以改*p=20;×

指针常量

int a = 10;
int b = 20;
int* const p = &a;

const修饰常量——指针常量
特点：指针的指向不可以修改p=&b;×
但指针指向的值可以改*p=20;√

const既修饰指针，又修饰常量

int a = 10;
int b = 20;
const int* const p = &a;

特点：指针的指向和指针指向的值都不可以修改

指针和数组

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

int* p = arr;//arr是数组的首地址名字，所以指针p就是数组的首地址，
//解引用之后输出的是第一个元素

利用指针输出所有元素

int* p = arr;
for (int i = 0; i < 10; i++) {
	cout << *p << endl;
	p++;//即指针向后移了4个字节，对应第2个元素
}

指针和函数

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

int main() {
	int a = 10;
	int b = 20;
	swap(a, b);

	system("pause");
	return 0;
}

void swap(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}
//值传递不改变实参

地址传递

int main() {
	int a = 10;
	int b = 20;
	swap(&a, &b);

	system("pause");
	return 0;
}

void swap(int* a, int* b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}
//地址传递会改变实参

注：在声明指针时，*表明这是一个指针变量
在赋值时，*表示解引用

int main() {
	int arr[10] = { 1,2,3,4,5 };
	int len = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, len);
	system("pause");
	return 0;
}

void BubbleSort(int*arr, int len) {
	//传入的是数组名arr，这是一个地址，因此用指针(int*arr)来接收，或者用数组名(int arr[])来接收
	//不管用什么接收，在后续操作时都可以将其看成数组来编写代码
	int temp = arr[j];
	arr[j] = arr[i];
	arr[i] = temp;
}