目录
输入输出
输出
int a = 10;
cout << "a = " << a << endl;输入
// cin
int a = 0;
cout << "请给变量a赋值：" << endl;
cin >> a;
cout << "a的值为：" << a << endl;定义常量（两种方式）
define （宏常量）
#define Day 7
// 放在 main 函数上方，后面不需要加分号const
const int b = 15;
// 放在 main 函数中，加分号数据类型
整型
短整型 （ -2^15 ~ 2^15-1 ）
整型 （ -2^31 ~ 2^ 31-1 ）
长整型，长长整型
数据类型占用内存的大小使用 sizeof 查询
sizeof(数据类型或者变量)
实型（浮点型）
单精度 float 7位有效数字 初始化单精度时，往往在数字后加 f 例如 float a = 3.14f;
双精度 double 15~16位有效数字
默认情况下，会输出六位有效数字
科学计数法
3e2 3*10^2
3e-2 3*0.1^2e
字符型
char i = 'a';
// 只占用一个字节
// 只能用单引号，单引号中只能有一个字符
// 存储字符型变量时不是把字符本身放入内存中，而是存放ASCII码转义字符
// 输出 \
cout << "\\" << endl;
// 输出水平制表符，调整输出格式
cout << "aaa\tHello World!" << endl;
cout << "aaaaaa\tHello World!" << endl;
cout << "a\tHello World!" << endl;
/*
\
aaa Hello World!
aaaaaa Hello World!
a Hello World!
*/字符串类型
// C 语言风格
char a[] = "Hello World!";
// 与字符类型不同的是：加中括号
// 要使用双引号
// C ++ 风格（要有string头文件）
string str = "Hello World";
// 同样只能双引号
布尔类型
bool a = true;
// 所占内存为 1
// 1 代表真 0 代表假运算符
算数运算符
注意整数除法时，两个整数相除，结果为整数
int a = 10;
int b = 7;
// 两个整数相除，得到的结果依然是整数
cout << a / b << endl;
// 结果为 1取模运算中不能有小数
赋值运算符
比较运算符
逻辑运算符
! && || 非 与 或
三种结构
顺序
选择（if，switch，三目运算符）
// 注意 if 条件判断后面不加分号
if (x > 5)
{
cout << "输入的数字大于5" << endl;
}
else if (x >= 4)
{
cout << "输入的数字大于4" << endl;
}
else
{
cout << "输入的数字小于4" << endl;
}
// 三目运算符
// switch循环（while，do...while，for）
和其他语言类似，注意格式即可
int a = 0;
while (a < 5)
{
cout << a << endl;
a++;
} int a = 0;
do
{
cout << a << endl;
a++;
} while (a < 5); int a = 0;
for (int i = 0; i < 10; i++)
{
a++;
cout << a << endl;
}break
1 switch中跳出 switch
2 跳出最近的循环体（如果在循环的if中，也是结束整个循环体）
continue
跳过下面的语句，再次开始循环（用来筛选条件） 例如：只输出奇数
goto
无条件跳转
goto A;
cout << 1 << " ";
cout << 2 << " ";
A:
cout << 3 << " ";
cout << 4 << endl; // endl相当于输出换行数组
1、占用连续的内存
2、数据类型一致
一维数组
// 第一种方式，必须告知数组长度
int arr[5];
arr[0] = 1;
// 第二种方式
int arr2[5] = { 1, 2, 3, 4, 5 };
// 第三种方式
int arr3[] = { 1, 2, 3 };数组名的用途
int a[] = { 1, 2, 3, 4, 5 };
// 数组名的用途
// 统计所占内存长度
cout << "数组a所占内存为：" << sizeof(a) << endl;
// 获取内存中首地址,加 int 把16进制转化为十进制
cout << "数组的首地址为：" << int(a) << endl;
cout << "第一个元素地址为：" << int(&a[0]) << endl;统计数组的元素个数：sizeof(a) / sizeof(a[0])
二维数组
// 第一种
int a[3][4];
a[0][0] = 1;
// 第二种（推荐）
int a[2][3] = { {1, 2, 3},
{4, 5, 6} };
// 第三种
int a[2][3] = { 1, 2, 3, 4, 5, 6 };
// 第四种（只能省略行数）
int a[][3] = { 1, 2, 3, 4, 5, 6 };函数
int add(int x, int y)
{
int sum = 0;
sum = x + y;
return sum;
}
int main()
{
int x = 5;
int y = 6;
int sum;
sum = add(x, y);
cout << sum << endl;
system("pause");
return 0;
}
函数的分文件编写
.h 头文件
.cpp 源文件
头文件中写声明，源文件中写定义
在使用头文件时，需要添加 #include "xxx.h"
指针
int * p;
int x = 6;
p = &x;
cout << "x的地址为：" << p << endl;
cout << "x的地址为" << &x << endl;
cout << *p << endl;& 取地址符
*p 相当于 x
32位 指针都是占四个字节空间，64位 都是占八个字节空间。
空指针与野指针
空指针
用于初始化指针，空指针不能访问（不能赋值等等，因为编号为0的空间被系统占用）
int* p = NULL;野指针
指针指向非法的内存空间，及操作没有申请的空间。
const 修饰指针
常量指针
int a = 0, b = 0;
// 常量指针（指针指向可以改，指针指向内容不能改）
const int* p = &a;
p = &b;
// *p = 5; 错误指针常量
int a = 0, b = 0;
// 指针常量（指针的指向不能改，指针指向的值可以改）
int* const p = &a;
// p = &b; 错误
*p = 5; 既修饰指针又修饰常量
const int * const p = &a;
看 const 在什么前面就限制什么。
指针的应用
指针与数组
int arr[5] = { 1, 2, 3, 4, 5 };
int* p = arr;
for (int i = 0; i < 5; i++)
{
// cout << *(p+i) << " "; //第一种方式
cout << *p << " ";
p++;
}指针与函数（地址传递）
可以修改实参的值
void swap(int* x, int* y)
{
int tmp = 0;
tmp = *x;
*x = *y;
*y = tmp;
}
int main()
{
int a = 6;
int b = 8;
swap(&a, &b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}结构体
自定义数据类型
普通结构体
struct Student
{
string name;
int age;
float score;
};
int main()
{
// 三种方式创建变量，在创建具体变量时，struct 可以省略
// 第一种
struct Student s1; // 或者 Student s1;
s1.name = "Lu Yaoyi";
s1.age = 18;
s1.score = 99;
// 第二种
struct Student s2 = { "Lu Yaoyi", 18, 99 };
// 第三种，在创建结构体变量时创建 即在main()函数外创建，不推荐
system("pause");
return 0;
}
结构体数组
struct Student stuArray[4] =
{
{"张三", 18, 100},
{"张四", 18, 77},
{"张五", 17, 66}
};结构体指针
struct Student s = { "lyy", 18, 99 };
struct Student* p = &s;
cout << p->age << endl; // 相当于 s.age结构体嵌套
struct Student
{
string name;
int age;
float score;
};
struct Teacher
{
string name;
int age;
struct Student stu;
};
int main()
{
struct Teacher t;
t.name = "lyy";
t.age = 44;
t.stu.name = "lzz"; // 看这里
t.stu.age = 17;
system("pause");
return 0;
}
结构体作为函数参数的值传递和地址传递
地址传递可以通过非主函数修改实参的值
struct Student
{
string name;
int age;
float score;
};
// 值传递
void print_1(Student stu)
{
cout << "姓名：" << stu.name << " 年龄：" << stu.age << " 分数：" << stu.score << endl;
}
// 地址传递
void print_2(Student * p)
{
cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}
int main()
{
Student s = { "lyy", 18, 99 };
Student* p = &s;
print_1(s);
print_2(p);
system("pause");
return 0;
}
const 在子函数中防止误操作（相当于只读不可写）
struct Student
{
string name;
int age;
float score;
};
// 地址传递
void print(const Student * p)
{
// p->age = 66; 无法修改
cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}
int main()
{
Student s = { "lyy", 18, 99 };
Student* p = &s;
print(p);
system("pause");
return 0;
}
230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
