【c++学习笔记】-1 基础

头文件

#include 
#include 
#include "my_write.h"
1
2
3

一般，系统头文件用<>；自己写的头文件用""

注释

单行注释：//
多行注释：/* 注释的内容 */

常量

不可更改的数据
#define 常量名 值
const 数据类型 常量名 = 值

关键字

编译器征用的标识符（int、float等）

标识符命名规则

组成：字母、数字、下划线
注意：数字不能开头，不能是关键字

数据类型

意义：在创建变量和常量时，必须指定数据类型，否则无法分配内存

整型

分类：short、int、long、long long
查看数据类型占内存大小：sizeof（）

浮点型

• 单精度float：有效数字7位
• 双精度double：有效数字15~16位

如：4.556：有效数字是4位

字符型

ascll字码
占用字节：1
注：创建字符用单引号，如：‘b’、‘1’

转义字符

/*
转义字符：
	\n	换行
	\t	水平制表符
	\\	反斜杠
	\v	垂直制表符
*/
1
2
3
4
5
6
7

字符串

//char var[] = "string"
//string str = "string"
1
2

注意：双引号的字符串末尾有一个隐藏字符：‘/0’

布尔

值：true、false

运算符

• 算数运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符

算数运算符

/*
+、-、*、/、%
++
--
*/
1
2
3
4
5

赋值运算符

//	=、+=、-=、/=、*=、%=
1

比较运算符

表达式进行比较，返回真/假

//	==、！=、<、>、<=、>=
1

逻辑运算符

/*
！	非	!a
&&	与
||	或
*/
1
2
3
4
5

程序流程结构

/*
	顺序结构
	选择结构
	循环结构
*/
1
2
3
4
5

跳转

/*
	break		跳出 循环
	continue	跳过 一次循环
*/
1
2
3
4

数组

内存空间连续
元素的数据类型相同

//数组定义：
int a1[32];
char a2[]="123";
int a3[5]={1,2,3};
int a4[]={1,2,3};
1
2
3
4
5

数组名作用：
1.整个数组所占内存长度
2.数组在内存中的首地址

二维数组

//二维数组定义方式
int arr1[2][3]={{1,1,1},{2,2,2}};
int arr2[2][3];
int arr3[2][3]={1,2,3,4,5,6};
int arr4[][3]={1,2,3,4,5,6,7};
/*
		1	2	3
		4	5	6
		7
*/
1
2
3
4
5
6
7
8
9
10

函数

/*
返回类型 函数名(参数列表)
{

}

*/

void printHello()
{
	cout<<"hello world"<<endl;
}
void printNum(int n)
{
	cout<<"输出的数字："<<n<<endl;
}
int add(int a,int c)
{
	int d=a+c;
	return d;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

函数默认参数

• 左侧第一个默认参数之后，都必须是默认参数
• 函数声明、函数实现 只能有一个有默认参数

//左侧第一个默认参数之后，都必须是默认参数
int func(int a,int b,int c=10,int d=20)
{
	return a + b + c + d;
}
//函数声明和函数实现只能有一个有默认参数
int func1(int a, int b);
int func1(int a,int b=10)
{
	return a + b;
}

int main()
{
	int a = func(2, 3);
	int b = func1(2);
	cout << a << endl;
	cout << b << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

占位参数

注：占位参数可以有默认值

//               占位参数
void func(int a, int)
{
	cout << "num:" << a << endl;
}
//占位参数可以有默认参数
void func1(int a, int=10)
{
	cout << "num1:" << a << endl;
}

int main()
{
	func(13, 3);
	func1(10);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

函数重载

函数名称相同，提高复用性
条件：

• 函数名相同
• 同一个作用域下
• 参数类型或参数个数或参数类型的顺序不同

void func(int a)
{
	cout << "num--1:" << a << endl;
}
void func(int a, int)
{
	cout << "num--2:" << a << endl;
}

int main()
{
	func(13);//调用第一个
	func(10,4);//调用第二个
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

指针

//定义：
//数据类型 * 指针变量名；
int var=10;
int *p=&var;
int *p1;
p1=&var;
1
2
3
4
5
6

指针所占内存空间：是固定值，即地址编码的长度

空指针：暂时不知道指向何处的指针

//空指针   相当于给指针变量初始化
int *p=NULL;
//*p=10   报错,不可访问
1
2
3

野指针：随意指向一个地址，随意的地址一般是没有访问权限的，运行会报错

int *p=(int *)0xff00;//运行会崩
1

const修饰指针

int v=10;
int *p=&v;//指针指向、指向的值均可修改


int * const p1 =&v;//指针指向不可更改，指向的值可以修改

const int *p2=&v;//指向的值不可修改，指向可以修改

1
2
3
4
5
6
7
8

结构体

//struct 结构体名{};
//定义：
/*
	struct 结构体名 变量名
	struct 结构体名 变量名={变量值}
*/
struct Student
{
	string name;
	int age;
	int id;
}
Student s1;
Student s2={"cat",20,12345};
Student s1[] = { {"xiaoming",12,123454},{"zzz",23,345656} };
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注：结构体访问元素用“.”，指针用“->”

内存

• 代码区：存放二进制代码，由系统管理
• 全局区：存放全局变量、静态变量、常量
• 栈区：局部变量、函数的参数值（相当于临时的变量）
• 堆区：由程序员分配、释放

new

在堆区开辟数据，返回的是指针
释放用delete

int *p=new int(10);
int *p1=new int[10];//数组
//释放
delete p;
//释放数组
delete[] p1;
1
2
3
4
5
6

引用

作用：给变量起别名
语法：数据类型& 变量名=另一个变量名（相当于再起一个名字）
注意：
引用必须初始化（赋值）
引用初始化之后，不可更改

int a=10;
int& b=a;
1
2

若函数的返回值是引用，则函数可以作为左值

int& func()
{
	static int a = 10;//静态变量再全局区，程序结束后才会释放
	//int b = 10;  b是局部变量，出了这个范围就会释放
	return a;
}

int main()
{
	int& n = func();//相当于给a起别名n
	cout << n << endl;//10

	func() = 1100;//相当于给a赋值，即a=1100,
	cout << n << endl;//1100
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

常用

/*
int 
float
double
short

sizeof
&:取址

.
->

for 
while
if

continue
break

switch
*/


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

经验

函数用指针传值、引用传值时，为了防止误修改，可以用const修饰