词法记号
基本类型
关键字
https://blog.csdn.net/qq_35671135/article/details/88092382
点击链接跳转查看详细版本。
标识符
- 程序员定义的，命名程序正文中的一些实体的单词。
- 可以以_开头。
- cout可以命名为标识符，程序不会报错，但是使用了std命名空间会带来变量名冲突。
文字
- 直接用符号表示的数据
基本数据类型
另外：
-
整型表示十六进制时，要以0x开头；
整型可以用后缀字母L/l表示长整型，U/u表示无符号型；
short等只修饰int； -
实型常量是以文字出现的实数，表示形式分为一般形式（6.66）和指数形式（6.66E+2，即6.66×10²），默认为double型，加后缀F/f转换为float型；
-
字符常量：单引号括起来的一个字符，包括转义序列。
转义序列：
-
字符串常量：双引号括起，内存中末尾添加’\0’作为结尾标记。
变量
- 变量的存储类型：
auto：堆栈方式分配内存，暂时性存储，存储空间可以被变量多次覆盖使用。
register：存放在通用寄存器中。
extern：在所有函数和程序段中都可以引用。
static：固定地址中存放，在整个程序运行期间都有效。
操作符（运算符）
- 实现各种运算
- 算术运算符：注意后置先引用再计算。
赋值运算符：=
逗号运算
逻辑运算：其中关系运算= = 和！=优先级最低
条件运算符：三目运算符（C++唯一一个）
sizeof运算符：sizeof （类型名）/表达式
位运算：按位与（&）：同1为1；按位或（|）：有1为1；按位异或（^）:同0异1；按位取反（~）；移位（<</>>）:补0，大于号的方向是数移向的方向 - 运算符优先级与结合性
结合性（右→左)：&，*，~，！（ 其余按照中文逻辑及C++运算逻辑理解）
优先性：
记忆方法（下面有总结）：
–摘自《C语言程序设计实用问答》
问题：如何记住运算符的15种优先级和结合性？
解答：C语言中运算符种类比较繁多，优先级有15种，结合性有两种。
如何记忆两种结合性和15种优先级？下面讲述一种||记忆方法||。
||结合性||有两种，一种是自左至右，另一种是自右至左，大部分运算符的结合性是自左至右，只有单目运算符、三目运算符的赋值运算符的结合性自右至左。
||优先级||有15种。||记忆方法||如下：
记住一个最高的：构造类型的元素或成员以及小括号。
记住一个最低的：逗号运算符。
剩余的是一、二、三、赋值。
意思是单目、双目、三目和赋值运算符。
在诸多运算符中，又分为：
算术、关系、逻辑。
两种位操作运算符中，移位运算符在算术运算符后边，逻辑位运算符在逻辑运算符的前面。再细分如下：
算术运算符分 *，/，%高于+，-。
关系运算符中，〉，〉=，<，<=高于==，！=。
逻辑运算符中，除了逻辑求反（！）是单目外，逻辑与（&&）高于逻辑或（||）。
逻辑位运算符中，除了逻辑按位求反（~）外，按位与（&)高于按位半加（^)，高于按位或（|）。
这样就将15种优先级都记住了，再将记忆方法总结如下：
去掉一个最高的，去掉一个最低的，剩下的是一、二、三、赋值。双目运算符中，顺序为算术、关系和逻辑，移位和逻辑位插入其中。
- 数据类型转换
（1）隐含转换：算术运算和关系运算中若参与运算的操作数类型不一致，编译器自动对数据进行转换；类型越高，数据的表示范围越大，精度越高。
低→高
char short int unsigned long unsigned long float double
（2）显式转换：类型说明符（表达式）
这种转换是暂时的，变量所在的内存空间中的值并未真正改变。
分隔符
- 分隔各个词法记号或程序正文
- () {} . : ,
空白
- 用于指示词法记号的开始和结束位置
- 空格，制表符（Tab），垂直制表符（\t），换行符，回车，注释
构造类型
数组
- 相同数据变量的有序（数组元素在内存中连续存放，每个单元占4个byte）集合。
- 声明：数据类型（类型说明符） 标识符[常量表达式1][常量表达式2]…
当数组元素全部赋初值时，可以不指定长度 - 注意数组越界。
- 数组名指向数组首元素的内存地址。
- 数组的引用：数组名[整形表达式]
数组的引用只能引用数组元素，而不能引用整个数组 - 把数组作为函数参数时，一般不指定数组第一维的大小，即使被指定，也会被忽略。
- 对象数组：类名 数组名[常量表达式]
访问对象数组：数组名[下标表达式].成员名 - 二维数组：可以理解成一维数组的一维数组。
输出二维数组的第i行元素值：
for（int i=0;i<行数;i++）
for(int j=0;j<列数;j++)
cout<<*(*array+i)+j)<<" ";//输出array数组第i行元素
- 数组的应用：
- 求最值及其位置：
（1）一维：
#include<iostream>
using namespace std;
int main()
{
int m = 0;
int a[5] = { 1,3,5,7,9 };
int iMax = a[0];
for (int i = 0; i < 5; i++)
{
if (a[i] > iMax)
{
iMax = a[i];
m = i;
}
}
cout << "该数组的最大值为" << iMax << ",是数组的第" << (m + 1) << "个元素" << endl;
return 0;
}
运行结果为：
该数组的最大值为9,是数组的第5个元素
（2）二维：
#include<iostream>
using namespace std;
int main()
{
int m,n = 0;
int a[2][3] = { {1,2,3},{4,5,6} };
int iMax = a[0][0];
for (int i = 0; i < 2; i++)
{
for(int j =0; j < 3; j++)
//二重循环遍历
if (a[i][j] > iMax)
{
iMax = a[i][j];
m = i;
n = j;
}
}
cout << "该数组的最大值为" << iMax << ",在数组的第" << (m + 1) << "行第" <<(n+1)<<"列"<< endl;
return 0;
}
运行结果为：
该数组的最大值为6,在数组的第2行第3列
- 查找（利用iFlag=0）
（1）顺序查找
#include<iostream>
using namespace std;
int main()
{
int iFlag = 0;
int a[6] = { 1,2,3,4,5,6 };
int c;
cout << "请输入要查找的元素" << endl;
cin >> c;
for (int i = 0; i < 6; i++)
{
if (a[i] == c)
{
iFlag = 1;
}
}
if (iFlag)
{
cout << "找得到该元素" << endl;
}
else
{
cout << "找不到该元素" << endl;
}
return 0;
}
（2）二分查找（数组中元素必须有序）
#include<iostream>
using namespace std;
int main()
{
int iFlag = 0;
int a[6] = { 1,2,3,4,5,6 };
int low = 0, high = 5, mid;
int c;
cout << "请输入要查找的元素" << endl;
cin >> c;
while (low <= high)
{
mid = (low + high) / 2;
if (a[mid] == c)
{
iFlag = 1;
cout << "找得到该元素" << endl;
break;
}
else if (a[mid] < c)
{
low = mid + 1;
}
else
{
high = mid - 1;
}
}
if (iFlag==0)
{
cout << "找不到该元素" << endl;
}
return 0;
}
- 排序
（1）冒泡（存在无效交换）
#include<iostream>
using namespace std;
int main()
{
int a[6] = { 3,2,1,7,5,6 };
for (int i = 0; i < (6 - 1); i++) {
for (int j = 0; j < (6 - 1 - i); j++) {
if (a[j] > a[j + 1]) { // 注意此处是j+1，j是从0开始的
int temp = a[j + 1]; // 元素交换
a[j + 1] = a[j];
a[j] = temp;
}
}
}
cout << "排序后的数组为";
for (int m = 0; m < 6; m++)
cout <<a[m];
return 0;
}
（2）选择
#include<iostream>
using namespace std;
int main()
{
int a[6] = { 3,2,1,7,5,6 };
for (int i = 0; i < (6 - 1); i++) {
int min = i;
for (int j = i + 1; j < 6; j++) {
if (a[j] < a[min]) { // 寻找最小的数
min = j;
}
}
int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
cout << "排序后的数组为";
for (int m = 0; m < 6; m++)
cout << a[m];
return 0;
}
- 数组与矩阵（记得利用for遍历）：
（1）矩阵相关算法（有关对角线）：找普遍规律
如主对角线元素：i==j；a[i][j];
（2）矩阵及元素求和；
（3）转置：①非方阵：矩阵a的转置阵b，利用for循环遍历b[j][i]=a[i][j];
#include<iostream>
using namespace std;
int main()
{
int a[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
int b[3][3];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
b[i][j] = a[j][i];
for (int m = 0; m < 3; m++)
{
for (int n = 0; n < 3; n++)
{
cout << b[m][n];
}
cout << endl;
}
return 0;
}
②方阵：对角线两边的对称元素交换，即a[i][j]和a[j][i]交换。
结构体
- 用户自定义的数据类型，可以用来存储不同的数据类型；
- 默认其中数据访问控制属性为public；
- 定义结构体：struct 结构体名称{}；
- 利用.和->访问成员
联合体
- 联合体的全部数据成员共享同一组内存单元。联合体变量中的成员同时只有至多一个是有意义的
- 定义形式：union 联合体名称{}；若不声明名称，为无名联合体
- 不能继承和多态，不能有自定义的一些东西
枚举
- 定义形式：enum 枚举类型名 {变量值列表}
- 其中的元素按常量处理，不能对它们赋值，它们有默认值，依次为0，1，2，…也可以在声明时另行定义枚举元素的值。
指针类型
- C++程序利用内存单元存储数据：通过变量名或地址；若是动态分配的内存单元无变量名，只能通过地址访问。（通过变量名访问是直接的，通过指针是间接的）
- 具有指针类型的变量称为指针变量，指针变量用于储存内存单元。
- 定义：存储类型 指针所指向对象的类型 *指针变量名（←也就是标识符）=初始地址；
必须先赋值（单独赋值语句：指针名=地址）才可以引用；
数组名称（可以表示数组的起始地址）属于指针常量。 - 与地址相关的运算符：
（1）*：解析，获取指针所指向变量的值
（2）&：取地址（出现在被声明变量左边表示引用，在等号右边或在被执行语句中作为一元运算符存在时，表示取对象的地址）
（3）指向常量的指针：
const *p 不能通过指针来改变所指对象的值，但指针本身可以指向另外的对象；
指针类型的常量：*const p
指针本身的值不能被改变
void类型的指针通过显示类型转换，可以访问任何类型的数据。
（4）指针是一种数据类型，其内容是变量的地址，故运算结果一定要符合地址逻辑。
（5）*（p1+n1）表示p1当前所指位置后方第n1个数的内容，也可以写作p1[n1]
5. 0专用于表示空指针，不指向任何内存地址（若不便于用一个有效地址给指针赋初值，用0作为它的初值，来避免指向不确定地址的指针出现），空指针也可以用NULL来表示。
6. 指针数组：数组的每个元素都是指针变量，指针数组的每个元素都必须是同一类型的指针。
7. （1）指针型函数：这个函数的返回值是指针类型；
目的：在函数结束时把大量的数据从被调函数返回到主调函数中（非指针型函数调用结束后通常只返回一个变量或数据）；
定义形式：数据类型 *函数名（参数表）{函数体}
（2）函数指针：专门用来存放函数代码首地址的变量，在使用之前也需要赋值，是指针指向一个已经存在的函数代码的起始地址（指针函数名=函数名）。
声明：数据类型（*函数指针名）（形参表）
利用typedef可以给它的声明起别名，第一次声明时在最前加typedef，之后起别名只需要 函数指针名 别名
8. 对象指针：用于存储对象地址的变量
声明：类名 * 对象指针名
访问对象成员：对象指针名->成员名 等价于 （*对象指针名）.成员名
9. this指针：隐含于每一个类的非静态成员函数中的特殊指针，用于指向正在被成员函数操作的对象。在成员函数中，可以使用 *this来标识正在调用该函数的对象
空类型
void：放在函数前面，表示该函数不返回任何值，放在函数参数部分，表示函数不传入参数（此处与空括号区别，空括号表示可以传入任意参数）。
参考书籍：《清华大学计算机系列教材：C++语言程序设计（第4版）》
欢迎指正与讨论
扫一扫
26万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
