C++学习笔记 Ⅰ

C++学习笔记 Ⅰ

书写一个简单程序

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

结果：
c++

变量

给一个指定的内存空间起名；

变量创建语法：

数据类型 变量名 = 变量初始值；
 int a = 10;

int a = 10;
cout<<a<<endl;

结果：
10

常量

记录程序中不可更改的数据；
更改该数据会报错。

宏常量

#define 宏常量

#include<iostream>
using namespace std;
#define Day 7;
int main()
{
	cout << "一周一共有" << Day << "天。"<< endl;
	return 0;
}

结果：
一周一共有7天。

修饰的常量

const

#include<iostream>
using namespace std;
const  int  Day = 7;
int main()
{
	cout << "一周一共有" << Day << "天。" << endl;
	return 0;
}

一周一共有7天。

关键字（标识符）

定义时不可用；

标识符定义规则

1.标识符不能是关键字；
2.标识符只能由数字、字母、下划线组成；
3.第一个字符必须是字母或下划线；
4.标识符区分大小写；

数据类型

必须给变量赋数据类型，否则无法分配合适的内存空间；

整型

整型	数据类型	占用空间	取值范围
短整型	short	2字节	(-215~215-1)
整型	int	4字节	(-231~231-1)
长整型	long	window为4字节Linux为4字节（32位），8字节（64位）	(-231~231-1)
长长整型	long long	8字节	(-263~263-1)

sizeof

利用求出数据类型占用内存大小
语法：sizeof （数据类型/变量）

short a = 10;
cout<<"short占用内存空间："<<sizeof(a)<<endl;

结果：
short占用得内存空间：2

实型（浮点型）

用于表示小数
1.单精度 float
2.双精度 double

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

字符型

字符型变量用于表示单个字符

char ch = 'a';

注意：
1.在使用字符变量时，用单引号将字符括起来；
2.单引号内只能放一个字符，不能放字符串；
3.C和C++中字符型变量只占用1个字节；
4.字符变量不是把字符本身放到内存中存储，而是将字符转换为ASCII编码放到存储单元中；

char ch = 'a';
cout << (int)ch <<endl;

结果：
97
解释：
字母a对应ASCII编码为97

char ch = 'A';
cout << (int)ch <<endl;

结果：
65
解释：
字母A对应ASCII编码为65

转义字符

用于一些不能显示出得ASCII字符

转义字符	含义	ASCII编码
\n	换行	010
\t	水平制表（跳到下一个Tab位置）	009
\	代表一个反斜杠“\”	092

字符串型

用于表示一个字符串

\\C
char 变量名[] = "字符串值"；
char ch[] = "abc";

\\C++
string 变量名 = "字符串值";
string ch = "abc";

注意：
使用前要加头文件 #include <string>

布尔类型

布尔数据类型代表真假值
bool类型只有两个值：
1.true —真（本质是1）
2.false —假（本质是0）
bool类型只占一个字节大小
注意：
非0的值都代表1；

数据输入

从键盘中获取数据

cin >> 变量；

int a 
cout << "输入a的值：";
cin >> a ;
cout <<"a的值为："<<endl;

结果：
输入a的值：
1
a的值为：1

运算符

用于执行代码的运算

算术运算符

用于处理四则运算

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10+5	15
-	减	10-5	10
*	乘	10*2	20
/	除	10/2	5
%	取模（取余）	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

注意：
1.两个整数相除，得到的是整数，小数部分自动抹除；
2.除数不可以为0；
3.两个小数可以相除，运算结果也可以是小数；
4.两个小数不可以做取模运算；
5.前置后置区别：
前置：先让变量+1，然后进行表达式运算；
后置：先进行表达式运算，再让变量+1；

赋值运算符

用于将表达式赋值给变量

运算符	术语	示例	结果
=	赋值	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=10;a%=3	a=1

比较运算符

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

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

三目运算符

通过三目运算符实现简单的判断
语法： 表达式1？表达式2：表达式3
解释： 如果表达式1为真，则执行表达式2，否则执行表达式3

#include<iostream>
using namespace std;
//判断三个数中最大的数
int main()
{
	int num1, num2, num3, x, y;
	cout << "请输入三个数：" << endl;
	cin >> num1 >> num2 >> num3;
	x = (num1 > num2 ? num1 : num2);
	y = (x > num3 ? x : num3);
	cout << "最大的数是：" << y << endl;
	return 0;
}

结果：

逻辑运算符

用于根据表达式的值返回真值或假值

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

程序流程结构

顺序结构

程序按顺序执行，不发生跳转

选择结构

依据条件是否满足，有选择的执行跳转

if语句

1.单行格式的选择语句
if(条件）{条件满足时执行的代码}

2.多行格式的if语句

if(条件){满足条件时执行的程序}
else{不满足条件时执行的程序}

3.多条件if语句

if(条件1）{
	条件1满足执行语句
}
if(条件2）{
	条件2满足执行语句
}
if(条件3）{
	条件3满足执行语句
}
...
else{
	都不满足执行语句
}

嵌套if语句

在if语句中，可以嵌套使用if语句，达到更精准的判断
``
if(条件1）{
if(条件1）{
条件1满足执行语句
}
if(条件1）{
条件1满足执行语句
}
}
例：判断三个数中最大的数

#include<iostream>
using namespace std;
//判断三个数中最大的数
int main()
{
	int num1, num2, num3;
	cout << "请输入三个数：" << endl;
	cin >> num1 >> num2 >> num3;
	if ( num1 > num2)
	{
		if (num1 > num3)
		{
			cout << num1 << endl;
		}
		else
		{
			cout << num3 << endl;
		}
	}
	else
	{
		if (num2 > num3)
		{
			cout << num2 << endl;
		}
		else
		{
			cout << num3 << endl;
		}
	}
	return 0;
}

结果：

switch语句

执行多条件分支语句
语法

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

注意：
每个分支结束时一定要有break；

循环结构

依据条件是否满足，循环多次执行代码

while循环

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

while(循环条件){执行语句}

只要循环条件为真，就执行循环语句

例：猜数字

#include<iostream>
using namespace std;
//猜数字 1~100
int main()
{
	int j =0;
	//生成随机数
	srand((unsigned int)time(NULL));
	int i = rand() % 100 + 1;
	while (1)
	{
		cout << "输入您猜测的数：" << endl;
		cin >> j;
		if (j > i)
		{
			cout << "猜测过大" << endl;
		}
		else if (j < i)
		{
			cout << "猜测过小" << endl;
		}
		else
		{
			cout << "恭喜您！猜对了！" << endl;
			break;
		}
	}
	return 0;
}

结果：

注意：
必须提供循环出口，否则会进行死循环

do…while循环

语法：

do{循环语句}while(循环条件)；

区别：先执行一次循环，再判断是否符合条件；

for循环

语法：

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

例：逢7

#include<iostream>
using namespace std;
//逢7
//分析：
//7的倍数： 7 14 21 28 ... %7=0 
//个位有7： 17 27 37...    %10=7
//十位有7： 70 71 72...    /10=7
int main()
{
	for (int i=1; i <= 100; i++)
	{
		if (i % 7 == 0|| i % 10 == 7|| i / 10 == 7)
		{
			cout << "过" << endl;
		}
		else
		{
			cout << i << endl;
		}
	}
	return 0;
}

结果：

嵌套循环

在循环体中再套一层循环
例：99乘法表

#include<iostream>
using namespace std;
//99乘法表
int i, j;
int main()
{
	for (i=1; i <= 9; i++)
	{
		for (j = 1; j <= i; j++)
		{
			cout << j << "*" << i << "=" << i * j <<" ";
		}
		cout << endl;
	}
	return 0;
}

结果：

break语句

用于跳出选择结构或循环结构
使用时机：
1.出现在switch语句中，作用是终止case并跳出switch
2.出现在循环语句中，作用是跳出当前循环语句
3.出现在嵌套循环中，作用是跳出最近的内层循环语句

continue语句

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

goto语句

可以无条件跳转语句

数组

一个存放相同数据类型的集合
特点：
1.数组中每个数据元素都是相同的数据类型
2.数组是有连续内存位置组成的

一维数组

定义方法

1. 数据类型 数组名 [数组长度];
2. 数据类型 数组名 [数组长度] = { n1,n2…};
3. 数据类型 数组名 [ ] = { n1,n2…};
   

名称用法

1. 可以统计整个数组在内存中的长度
2. 可以获取数组在内存中的首地址
3. 数组名是常量，不可以赋值
   整个数组长度： sizeof (arr)
   数组元素长度： sizeof(arr[0])
   数组元素：sizeof(arr) / sizeof(arr[0])
   首地址：cout << arr << endl;
   取元素首地址：cout << &arr[0] << endl;
   
   例：打印出一个数组中的最大值

#include <iostream>
using namespace std;

int arr[5] = { 100,500,200,165,400 };
int main()
{
	int max = 0;
	for (int i = 0; i < 5; i++)
	{
		max = max > arr[i] ? max : arr[i];
	}
	cout << "最大的数为：" << max << endl;
}

结果：500
例：倒序打印数组

#include <iostream>
using namespace std;

int arr[5] = { 1,2,3,4,5 };
int main()
{
	int temp = arr[0];
	int start = 0;
	int	end = sizeof(arr) / sizeof(arr[0]) - 1;
	while (start < end)
	{
		temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		start++;
		end--;
	}
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}
}

结果：
5
4
3
2
1
例 ：冒泡排序

#include <iostream>
using namespace std;


int main()
{
	int arr[] = { 4,2,8,0,5,7,1,3,9 };
	int end = sizeof(arr) / sizeof(arr[0]) - 1;
	cout << "排序前顺序：" << endl;
	for (int i = 0; i < end; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	for (int i = 0; i < end + 1; i++)
	{
		for (int j = 0; j < end - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	cout << "排序后顺序：" << endl;
	for (int i = 0; i < end; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

结果：

二维数组

二维数组定义

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

二维数组名称

1. 查看占用空间
2. 获取首地址

1）二维数组占用的内存空间

cout << sizeof(arr) ;

2）二维数组第一行所占用的内存空间

cout << sizeof(arr[0]);

3）二维数组第一个元素所占用的内存空间

cout <<sizeof[0][0];

4)二维数组行数

cout << sizeof(arr) / sizeof(arr[0]);

5）二维数组列数

cout << sizeof(arr[0] / sizeof(arr[0][0];

函数

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

函数的定义

函数的定义一般主要有5个步骤

1. 返回值类型
2. 函数名
3. 参数列表
4. 函数体语句
5. return 表达式
   语法：

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

如果函数不需要返回值，声明里可以写 void
返回值不需要的时候，可以不写return

函数的调用

**语法：**函数名（参数）
函数定义里小括号内成为形参，函数调用时传入的参数叫做实参。

值传递

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

函数常见样式

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

函数的声明

告诉编译器函数名称及如何调用函数，函数的实际主体可以单独调用
**注意：**声明可以多次，定义只能一次

函数的分文件编写

可以使代码更加清晰
步骤：

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