- 1.变量——给内存空间起名，方便管理内存
- 2.常量——记录程序中不可更改的数据
- 3.关键字——C++中预先保留的单词
- 4.标识符命名规则——（变量，常量）命名规则
- 5.数据类型——给变量分配一个合适的内存空间（不同类型分配的内存空间是不一样的，空间越大取值范围越广）
- 5.1整型
- 5.2size关键字——统计数据类型所占大小
- 5.3实型（浮点型）
- 5.4字符型
- 5.5转义字符
- 5.6字符串型
- 5.7布尔类型
- 5.8数据的输入
- 6.运算符——用于执行代码运算
- 6.1算术运算符——处理四则运算
- 6.2赋值运算符——将表达式的值赋给变量
- 6.3比较运算符——比较表达式，并返回真或假
- 6.4逻辑运算符——根据表达式的值，返回真或假
- 7.程序流程结构——顺序，选择，循环
- 7.1选择结构
- if语句
- 三目运算符
- switch语句
- 7.2循环结构
- while循环
- do...while循环
- for循环
- 嵌套循环
- 7.3跳转语句
- break语句
- continue语句
- goto语句
- 8.数组——相同数据类型的数据元素的集合（数据类型相同、连续的内存位置）
- 8.1一维数组
- 8.2二维数组
- 9.函数——将一段经常使用的代码封装起来，减少代码
- 9.1定义
- 9.2调用
- 9.3样式
- 9.4声明
- 9.5分文件编写
- 10.指针——可以通过指针间接访问内存
- 10.1指针的定义和使用
- 10.2空指针
- 10.3野指针
- 10.4const修饰指针
- 10.5指针和数组
- 10.6指针和函数
- 11.结构体——属于用户自定义的数据类型，允许用户储存不同的数据类型
- 11.1定义及使用
- 11.2结构体数组
- 11.3结构体指针
- 11.4结构体嵌套
- 11.5结构体做函数参数
- 11.6结构体中const使用场景
//数据类型 + 变量名 = 起始值；
int a = 1;
//#define 常量名 常量值
#define day 7
//const 数据类型 + 变量名 = 起始值；
const month = 12;
- 定义变量或者常量的时候，不要用关键字（会发生歧义）
- 标识符不能是关键字
- 标识符由字母、数字、下划线组成
- 第一个字符必须为字母或者下划线
- 标识符中字母区分大小写
| 数据类型 | 占用空间 | 取值范围 |
|---|---|---|
| short——短整型 | 2字节 | -2^15 ~ 2^15-1 |
| int——整型 | 4字节 | -2^31 ~ 2^31-1 |
| long——长整型 | windows下4字节，linux_32位下4字节，linux_64位下8字节 | -2^31 ~ 2^31-1 |
| long long ——长长整型 | 8字节 | -2^63 ~ 2^63-1 |
//sizeof(数据类型/变量)
cout << sizeof(int) << endl;
| 数据类型 | 占用空间 | 取值范围 |
|---|---|---|
| float——单精度 | 4字节 | 7位有效数字 |
| double——双精度 | 8字节 | 15 ~ 16位有效数字 |
//如果不加f(3.14)会自动转换为double
float f1 = 3.14f;
//科学计数法：
//3*10^2
float f1 = 3e2;
//3*0.1^2
float f2 = 3e-2;
-
用单引号括值
-
单引号内只能有一个字符
//求字符型变量对应的ASCⅡ码
//a - 97
//A - 65
char ch = 'a';
cout << (int)ch <| 转义字符 | 含义 | ACSⅡ码 |
|---|---|---|
| \n | 换行 | 010 |
| \t | TAB | 009 |
| \ | “\” | 092 |
-
C风格字符串
//char 变量名[] = "字符串值"; char str1[] = "hello world"; cout << str1 << endl; -
C++风格字符串
//首先需要导入#include//string 变量名[] = "字符串值"; string str2 = "hello world"; cout << str2 << endl;
-
true —— 真（1）
-
false —— 假（0）
bool flag = true; //返回1（因为true） cout << flag << endl;
-
从键盘获取数据
//cin >> 变量 int a = 0; cout << "请输入整形变量：" << endl; cin >> a; cout << a << endl;
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| + | 正号 | +1 | 1 |
| - | 负号 | -1 | -1 |
| + | 加 | 1+1 | 2 |
| - | 减 | 1-1 | 0 |
| * | 乘 | 2*2 | 4 |
| / | 除 | 2/2 | 1 |
| % | 取模（取余） | 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; |
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| = | 赋值 | 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=3;a%=2; | a=1; |
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4 == 3 | 0 |
| != | 不等于 | 4 !=3 | 1 |
| < | 小于 | 4 < 3 | 0 |
| > | 大于 | 4 > 3 | 1 |
| <= | 小于等于 | 4 <= 3 | 0 |
| >= | 大于等于 | 4 >= 3 | 1 |
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| ! | 非 | !a | 如果a假，!a真；如果a真，!a假。 |
| && | 与 | a && b | 如果a和b都真，结果真，否则假 |
| || | 或 | a || b | 如果a和b有一个真，结果真，否则假 |
- if语句
单行、多行、多条件、嵌套
- 三目运算符
表达式1 ? 表达式2 : 表达式3 //表达式1真 -> 表达式2，否则表达式3 - switch语句
switch(表达式) { case 结果1: 执行语句;back; case 结果1: 执行语句;back; default: 执行语句;back; }
- while循环
while(循环条件){循环语句} - do…while循环
do{循环语句}while{循环条件}; - for循环
for(起始表达式;条件表达式;末尾循环体){循环语句;} - 嵌套循环
循环套循环
- break语句
跳出选择结构或者循环结构
- continue语句
循环语句中，跳过本次循环，继续下一次循环
- goto语句
跳转到标记的位置
跳过“3.___” cout << "1.___" << endl; cout << "2.___" << endl; goto FLAG; cout << "3.___" << endl; FLAG: cout << "4.___" << endl;
-
定义
//数据类型 数组名[数组长度]; int score[3]; //数据类型 数组名[数组长度] = {值1,值2，...};//起始化中没定值的数据会用0来填补 int score[4] = {5,5,5}; //数据类型 数组名[] = {值1,值2，...}; int score[] = {5,5,5};cout << "数组中元素个数为：" << sizeof(score) / sizeof(score[0]) < -
一些实例
//倒序排列 int main() { int arr[5] = { 1,2,3,4,5 }; int a = sizeof(arr)/ sizeof(arr[0]); int b; for (int i = 0; i < a; i++) { cout << arr[i] << ","; } cout << endl; cout << "a=" <
-
定义
//数据类型 数组名[ 行数 ][ 列数 ]; int score[2][3]; //数据类型 数组名[ 行数 ][ 列数 ] = {{值1,值2，...},{值n,值n+1，...}}; int score[2][3] = { {1,2,3}, {4,5,6} }; //数据类型 数组名[ 行数 ][ 列数 ] = {值1,值2，...}; int score[2][3] = {1,2,3,4,5,6}; //数据类型 数组名[ ][ 列数 ] = {值1,值2，...}; int score[][3] = {1,2,3,4,5,6};
//返回值类型 函数名(参数列表) {
函数体语句
return表达式
}
int add(int num1,int num2){
int sum = num1 + num2;
return sum;
}
//函数名(参数)
int main(){
int a = 1;
int b = 2;
//调用add函数
int sum = add(a,b);
cout << "sum=" << sum <- 无参无返
- 有参无返
- 无参有返
- 有参有返
//声明可以多次，定义只能一次
//声明
int max(int a,int b);
//定义
int max(int a,int b){
return a > b ? a : b;
}
//1.创建后缀名为.h的头文件
//2.创建后缀名为.cpp的源文件
//3.在头文件中写函数的声明
//4.在源文件中写函数的定义
//5.调用时引入头文件
//swap.h文件（头文件）
#include//引入c++框架
using namespace std;
void swap(int a,int b);
//swap.cpp文件（源文件）
#include"swap.h"//引入头文件
void swap(int a,int b){
int temp = a;
a = b;
b = temp;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
//调用函数的文件
#include
#include
using namespace std;
#include"swap.h"//引入头文件
int main() {
int a = 10;
int b = 20;
swap(a, b);
return 0;
}
//定义指针语法：数据类型 * 指针变量名
int a = 10;
int * p;//数据类型要一致（int 对 int）
p = &a;
cout << "a的地址为" << p <//使用指针（使用解引用的方法来找到指针所指向的内存）
*p = 1000;
cout << " a = " << a << emdl;
cout << " *p = " << *p <概念：指针变量指向内存中编号为0的空间
用途：起始化指针变量
注意：空指针指向的内存是不可以访问的
0~255之间的内存是系统占用的，因此不可以访问
解引用空指针——————程序崩溃
int * p = NULL;
cout << "指针p保存的低地址：" << p << endl;//结果为0
在程序中，应尽量避免，要求对暂时闲置的指针一定先初始化为NULL
概念：指针变量指向不可知的（随机的，不正确的，没又明确限制的）内存空间
解引用野指针——————程序数据错乱
int * p;//未起始化
int * p = NULL;
{
int number = 0;
p = &number;
}
cout << p <const修饰指针的三种情况：
-
const修饰指针——常量指针（指针的指向可以修改，但指针指向的值不可以改）
-
const修饰常量——指针常量（指针的指向不可以改，但指针的指向的值可以改）
-
const既修饰指针，又修饰常量（指针的指向不可以改，但指针的指向的值也不可以改）
//无修饰状态 int a = 10; int b = 20; int * p = &a;//常量指针 const int * p = &a;//指针常量 int * const p = &a;//既修饰指针又修饰常量 const int * const p = &a;
//利用指针访问数组中的元素
int main (){
int arr[] = { 1,2,3,4,5,6,7,8,9 };
int * p = arr;//指向数组的指针
cout << "第一个元素：" << arr[0] << endl;
cout << "指针访问第一个元素：" << *p << endl;
for (int i = 0;i < 9;i++){
//利用指针遍历数组
cout << *p << endl;
p++;
}
return 0;
}
//利用指针做函数参数，可以修改实参的值
//值传递
void swap1(int a,int b){
int temp = a;
a = b;
b = temp;
}
//地址传递
void swap2(int * p1,int * p2){
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main(){
int a = 10;
int b = 20;
swap1(a,b);//值传递不会改变实参
swap2(&a,&b);//地址传递会改变实参
cout << "a = " << a <//struct 结构体名 数组名[元素个数] = { {}, {}, ...{} }
struct Student {
string name;
int age;
int score;
};
int main() {
//结构体数组
struct Student arr[3] = {
{"张三", 15, 15},
{"李四", 13, 65},
{"王五", 18, 65}
};
arr[2].name = "安安";
arr[2].age = 56;
arr[2].score = 56;
for (int i = 0; i < 3; i++) {
cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
}
}
struct Student {
string name;
int age;
int score;
};
int main() {
struct Student stu = {"张三", 15, 15};
//结构体指针
struct Student * p = &stu;
for (int i = 0; i < 3; i++) {
cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}
}
struct Student {
string name;
int age;
int score;
};
struct Teacher {
int id;
string name;
int age;
//嵌套Student结构体
struct Student stu;
};
int main() {
Teacher t;
t.id = 1;
t.name = "老王";
t.age = 85;
t.stu.name = "张三";
t.stu.age = 12;
t.stu.score = 60;
cout << "老师姓名：" << t.name << " 老师年龄：" << t.age << " 学生姓名：" << t.stu.name << " 学生年龄：" << t.stu.age << " 学生分数：" << t.stu.score << endl;
}
struct Student {
string name;
int age;
int score;
};
//值传递
void printStudent(Student stu) {
stu.age = 24;
cout << "子函数中 姓名：" << stu.name << "年龄：" << stu.age << "分数：" << stu.score << endl;
}
//地址传递
void printStudent(Student * p) {
p->age = 24;
cout << "子函数中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}
int main() {
struct Student s;
s.name = "张三";
s.score = 54;
cout << "值传递" << endl;
printStudent(s);
cout << "地址传递" << endl;
printStudent(&s);
}
struct Student {
string name;
int age;
int score;
};
//使用地址传值是为了节省开销
void printStudent(const Student * p) {
//p->age = 24; //防止误 *** 作改变数据
cout << "子函数中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}
int main() {
struct Student s;
s.name = "张三";
s.age = 15;
s.score = 54;
cout << "地址传递" << endl;
printStudent(&s);
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）