目录
输入输出
输出
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;
}