2021-07-08 暑假实训第3，4天回顾

全局变量

全局变量
在所有函数外部定义的变量称为全局变量（Global Variable），它的作用域默认是整个程序，也就是所有的源文件。

局部变量
定义在函数内部的变量称为局部变量（Local Variable），它的作用域仅限于函数内部， 离开该函数的内部就是无效的，再使用就会报错。

二者区别
1、 定义的位置不一样
局部变量：在方法的内部;
成员变量：在方法的外部，直接写在类中；

2、作用范围不一样
局部变量：只有方法当中才可以使用，出了方法外就不能使用；
成员变量：整个类中都可以使用；

3、默认值不一样
局部变量：没有默认值，如果要想使用，必须手动赋值；
成员变量：如果没有赋值，会有默认值，规则和数组一样；

4、内存的位置不一样
局部变量：位于栈内存；
成员变量：位于堆内存；

#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<iostream>
using namespace std;
template<class Type>
class SeqStack
{
private:
	Type* data;
	int maxsize;
	int top;
public:
	SeqStack(int sz = 10) :maxsize(sz), top(-1)
	{
		data = (Type*)malloc(sizeof(Type) * maxsize);
		if (data == NULL) exit(1);

	}
	~SeqStack()
	{
		free(data);
		data = NULL;
		maxsize = 0;
		top = -1;
	}
	int GetSize() const
	{
		return top + 1;
	}
	bool Is_Empty() const
	{
		return GetSize() == 0;
	}
	bool Is_Full() const
	{
		return GetSize() == maxsize;
	}
	bool Push(const Type&x)
	{
		if (Is_Full())
			return false;
		data[++top] = x;
		return true;
	}
	Type& GetTop()
	{
		return data[top];

	}
	const Type& GetTop() const
	{
		return data[top];
	}
	void Pop()
	{
		--top;
	}
	void Clear()
	{
		top = -1;
	}
	};
int main()
{
	SeqStack<int> ist = SeqStack<int>();
	ist.Push(12);
	ist.Push(23);
	ist.Push(34);
	ist.Push(45);
	while (!ist.Is_Empty())
	{
		int x = ist.GetTop();
		ist.Pop();
		cout << x << endl;
	}
	return 0;

}

c语言32个关键字和9种控制语句

1 数据类型关键字（12个）：

(1) char ：声明字符型变量或函数
(2) double ：声明双精度变量或函数
(3) enum ：声明枚举类型
(4) float：声明浮点型变量或函数
(5) int： 声明整型变量或函数
(6) long ：声明长整型变量或函数
(7) short ：声明短整型变量或函数
(8) signed：声明有符号类型变量或函数
(9) struct：声明结构体变量或函数
(10) union：声明共用体（联合）数据类型
(11) unsigned：声明无符号类型变量或函数
(12) void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用）

2控制语句关键字（12个）：

A循环语句
(1) for：一种循环语句(可意会不可言传）
(2) do ：循环语句的循环体
(3) while ：循环语句的循环条件
(4) break：跳出当前循环
(5) continue：结束当前循环，开始下一轮循环
B条件语句
(1)if: 条件语句
(2)else ：条件语句否定分支（与 if 连用）
(3)goto：无条件跳转语句
C开关语句
(1)switch :用于开关语句
(2)case：开关语句分支
(3)default：开关语句中的“其他”分支
D返回语句
return ：子程序返回语句（可以带参数，也看不带参数）

3 存储类型关键字（4个）

(1)auto ：声明自动变量 一般不使用
(2)extern：声明变量是在其他文件正声明（也可以看做是引用变量）
(3)register：声明积存器变量
(4)static ：声明静态变量

4 其它关键字（4个）：

(1)const ：声明只读变量
(2)sizeof：计算数据类型长度
(3)typedef：用以给数据类型取别名（当然还有其他作用
(4)volatile：说明变量在程序执行中可被隐含地改变

二、C语言中的9种控制语句

goto语句:无条件转向;
if语句:判断语句;
while循环语句;
do-while语句:先执行循环体,然后判断循环条件是否成立. 之后继续循环;
for语句:循环,可替代while语句; 只是用法不同;
break语句跳出本层的循环;(只跳出包含此语句的循环)
continue语句:继续(一般放到循环语句里,不在执行它下面的语句,直接跳到判断语句例:for语句,就直接跳到第二个分号处,while语句,就直接跳到while()的括号里;
switch语句:多相选择;
return语句:返回;
本文介绍C语言中的关键字 typedef 的用法。

typedef的介绍

1 概述
typedef 为C语言的关键字，作用是为一种数据类型定义一个新名字，这里的数据类型包括内部数据类型（int，char等）和自定义的数据类型（struct等）。

typedef 本身是一种存储类的关键字，与 auto、extern、static、register 等关键字不能出现在同一个表达式中。

2 作用及用法
2.1 typedef的用法
使用 typedef 定义新类型的方法（步骤）：在传统的变量声明表达式里，用（新的）类型名替换变量名，然后把关键字 typedef 加在该语句的开头就可以了。

下面以两个示例，描述 typedef 的用法步骤。

示例1：

【第一步】：int a; ———— 传统变量声明表达式
【第二步】：int myint_t; ———— 使用新的类型名myint_t替换变量名a
【第三步】：typedef int myint_t; ———— 在语句开头加上typedef关键字，myint_t就是我们定义的新类型

示例2：

【第一步】：void (*pfunA)(int a); ———— 传统变量（函数）声明表达式
【第二步】：void (*PFUNA)(int a); ———— 使用新的类型名PFUNA替换变量名pfunA
【第三步】：typedef void (*PFUNA)(int a); ———— 在语句开头加上typedef关键字，PFUNA就是我们定义的新类型

特别强调：上述两个示例，仅仅为了演示 typedef 的用法步骤，便于新手记忆 typedef 的用法。在实际编写代码时，只有“第三步”对应的语句会写入代码中！

2.2 typedef的作用
typedef 的作用有以下几点：

1）typedef 的一个重要用途是定义机器无关的类型。例如，定义一个叫“REAL”的浮点类型，该浮点类型在目标机器上可以获得最高的精度：

typedef long double REAL;
如果在不支持 long double 的机器上运行相关代码，只需要修改对应的 typedef 语句，例如：

typedef double REAL;
或者：

typedef float REAL;
2）使用 typedef 为现有类型创建别名，给变量定义一个易于记忆且意义明确的新名字。例如:

typedef unsigned int UINT
3）使用 typedef 简化一些比较复杂的类型声明，例如：

typedef void (PFunCallBack)(char pMsg, unsigned int nMsgLen);
上述声明引入了 PFunCallBack 类型作为函数指针的同义字，该函数有两个类型分别为 char* 和 unsigned int 参数，以及一个类型为 void 的返回值。通常，当某个函数的参数是一个回调函数时，可能会用到 typedef 简化声明。

例如，承接上面的示例，我们再列举下列示例：

RedisSubCommand(const string& strKey, PFunCallBack pFunCallback, bool bOnlyOne);
注意：类型名 PFunCallBack 与变量名 pFunCallback 的大小写区别。

RedisSubCommand 函数的参数是一个 PFunCallBack 类型的回调函数，返回某个函数（pFunCallback）的地址。在这个示例中，如果不用 typedef，RedisSubCommand函数声明如下：

RedisSubCommand(const string& strKey, void (pFunCallback)(char pMsg, unsigned int nMsgLen), bool bOnlyOne);
从上面两条函数声明可以看出，不使用 typedef 的情况下，RedisSubCommand 函数的声明复杂得多，不利于代码的理解，并且增加的出错风险。

所以，在某些复杂的类型声明中，使用 typedef 进行声明的简化是很有必要的。

3 typedef与#define
两者的区别如下：

#define 进行简单的进行字符串替换。 #define 宏定义可以使用 #ifdef、#ifndef 等来进行逻辑判断，还可以使用 #undef 来取消定义。
typedef 是为一个类型起新名字。typedef 符合（C语言）范围规则，使用 typedef 定义的变量类型，其作用范围限制在所定义的函数或者文件内（取决于此变量定义的位置），而宏定义则没有这种特性。
通常，使用 typedef 要比使用 #define 要好，特别是在有指针的场合里。

下面列举几个示例。

3.1 示例1
代码如下：

typedef　char*　pStr1;
#define　pStr2　char*　
pStr1　s1, s2;
pStr2　s3, s4;
在上述的变量定义中，s1、s2、s3都被定义为 char* 类型；但是s4则定义成了 char 类型，而不是我们所预期的指针变量 char*，这是因为 #define 只做简单的字符串替换，替换后的相关代码等同于为：

char*　s3, s4;
而使用 typedef 为 char* 定义了新类型 pStr1 后，相关代码等同于为：

char *s3, *s4;
3.1 示例2
代码如下：

typedef char *pStr;
char string[5]=“test”;
const char *p1=string;
const pStr p2=string;
p1++;
p2++;
在编译过程中，报错如下：

根据上述错误信息能够看出，p2 为只读常量，所以 p2++ 出错了。这个问题再一次提醒我们：typedef 和 #define 不同，typedef 不是简单的文本替换，上述代码中 const pStr p2 并不等于 const char * p2，pStr 是作为一个类型存在的，所以 const pStr p2 实际上是限制了 pStr 类型的 p2 变量，对 p2 常量进行了只读限制。也就是说，const pStr p2 和 pStr const p2 本质上没有区别（可类比 const int p2 和 int const p2），都是对变量 p2 进行只读限制，只不过此处变量 p2 的数据类型是我们自己定义的 pStr，而不是系统固有类型（如 int）而已。

所以，const pStr p2 的含义是：限定数据类型为 char * 的变量 p2 为只读，因此 p2++ 错误。

注意：在本示例中，typedef 定义的新类型与编译系统固有的类型没有差别。

宏

#define 宏定义
在C或C++语言源程序中允许用一个标识符来表示一个字符串，称为“宏”。“define”为宏定义命令。

被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。

宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。

优点：

(1) 方便程序的修改。这个就不多说了。

（2） 提高程序的运行效率。使用带参数的宏定义可完成函数调用的功能，又能减少系统开销，提高运行效率。正如C语言中所讲，函数的使用可以使程序更加模块化，便于组织，而且可重复利用，但在发生函数调用时，需要保留调用函数的现场，以便子函数执行结束后能返回继续执行，同样在子函数执行完后要恢复调用函数的现场，这都需要一定的时间，如果子函数执行的操作比较多，这种转换时间开销可以忽略，但如果子函数完成的功能比较少，甚至于只完成一点操作，如一个乘法语句的操作，则这部分转换开销就相对较大了，但使用带参数的宏定义就不会出现这个问题，因为它是在预处理阶段即进行了宏展开，在执行时不需要转换，即在当地执行。宏定义可完成简单的操作，但复杂的操作还是要由函数调用来完成，而且宏定义所占用的目标代码空间相对较大。所以在使用时要依据具体情况来决定是否使用宏定义。

在C或C++语言中，“宏”分为有参数和无参数两种。

一、无参宏定义

1. 无参宏定义的一般形式为：#define 标识符 字符串

2. 其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。

#include <stdio.h>
#define M ( a+b )
int main( int argc, char * argv[] )
{
int s, a, b;
printf( "input number a& b: " );
scanf( “%d%d”, &a, &b );
s = MM;
printf( “s=%d\n” ,s );
}
上例程序中首先进行宏定义，定义M来替代表达式(a+b),在 s= M * M 中作了宏调用。在预处理时经宏展开后该语句变为： S=(a+b)(a+b) 但要注意的是，在宏定义中表达式(a+b)两边的括号不能少。否则会发生错误。

如当作以下定义后：#define M (a)+(b) 　在宏展开时将得到下述语句：S= (a)+(b)*(a)+(b)

还要说明的是：
1.宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。
2.宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。
3…宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#undef命令

二、带参宏定义
c语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。

带参宏定义的一般形式为： 　#define 宏名(形参表) 字符串

#define M(y) ((y)(y)+3(y)) /宏定义/
k = M(5); /宏调用/
如果想用宏定义实现max函数的话，写法如下：

#include
using namespace std;
#define MAX(a,b) (a<b)? b:a

int main(){
int a=6,b=2;
int c=MAX(a,b);
cout<<c<<endl;
}
因为MAX带有返回值，而且在等号右边，所以if语句的写法必须是这种形式，而不能是 if else;

宏定义也可以实现替换多条语句，如下例子：

#include
using namespace std;
#define fuck(a,b) a++; b++; for(int i=0; i<=10; i++) cout<<a<<" "<<b<<endl;

int main(){
int a=6,b=2;
fuck(a,b);
}

#ifndef 条件编译
　　它是if not define 的简写，是宏定义的一种，实际上确切的说，这应该是预处理功能三种（宏定义、文件包含、条件编译）中的一种----条件编译。

在c语言中，对同一个变量或者函数进行多次声明是不会报错的。所以如果h文件里只是进行了声明工作，即使不使用# ifndef宏定义，多个c文件包含同一个h文件也不会报错。

但是在c++语言中，#ifdef的作用域只是在单个文件中。所以如果h文件里定义了全局变量，即使采用#ifdef宏定义，多个c文件包含同一个h文件还是会出现全局变量重定义的错误。

使用#ifndef可以避免下面这种错误：如果在h文件中定义了全局变量，一个c文件包含同一个h文件多次，如果不加#ifndef宏定义，会出现变量重复定义的错误；如果加了#ifndef，则不会出现这种错误。

示例:

#ifndef x //先测试x是否被宏定义过
#define x
程序段1 //如果x没有被宏定义过，定义x，并编译程序段 1
#endif
　　程序段2　　 //如果x已经定义过了则编译程序段2的语句，“忽视”程序段 1
　　条件指示符#ifndef 的最主要目的是防止头文件的重复包含和编译。
了解：条件编译当然也可以用条件语句来实现。 但是用条件语句将会对整个源程序进行编译，生成的目标程序程序很长，而采用条件编译，则根据条件只编译其中的程序段1或程序段2，生成的目标程序较短。如果条件选择的程序段很长，采用条件编译的方法是十分必要的。

#ifndef 和 #endif 要一起使用，如果丢失#endif，可能会报错。总结一下：在c语言中，对同一个变量或者函数进行多次声明是不会报错的。所以如果h文件里只是进行了声明工作，即使不使用# ifndef宏定义，一个c文件多次包含同一个h文件也不会报错。　使用#ifndef可以避免下面这种错误：如果在h文件中定义了全局变量，一个c文件包含同一个h文件多次，如果不加#ifndef宏定义，会出现变量重复定义的错误；如果加了#ifndef，则不会出现这种错.

c++类的6种缺省函数

在C++中默认产生6个类成员函数，即缺省函数，它们分别是：
缺省构造函数
缺省拷贝构造函数
缺省析构函数
缺省赋值运算符
缺省取址运算符
缺省取地址运算符const

this指针

一、this指针的概念
定义
在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

this只能在成员函数中使用
成员函数默认第一个参数为T* const register this。
（友元函数，全局函数不是成员函数）

this指针不能再静态函数中使用
静态函数如同静态变量一样，他不属于具体的哪一个对象，静态函数表示了整个类范围意义上的信息，而this指针却实实在在的对应一个对象，所以this指针不能被静态函数使用。

this指针的创建
this指针在成员函数的开始执行前构造的，在成员的执行结束后清除。

this指针只有在成员函数中才有定义。
创建一个对象后，不能通过对象使用this指针。也无法知道一个对象的this指针的位置（只有在成员函数里才有this指针的位置）。当然，在成员函数里，你是可以知道this指针的位置的（可以&this获得)，也可以直接使用的。

栈

栈由操作系统自动分配释放 ，用于存放函数的参数值、局部变量等，其操作方式类似于数据结构中的栈。参考如下代码：

int main() {
int b; //栈
char s[] = “abc”; //栈
char *p2; //栈
}
其中函数中定义的局部变量按照先后定义的顺序依次压入栈中，也就是说相邻变量的地址之间不会存在其它变量。栈的内存地址生长方向与堆相反，由高到底，所以后定义的变量地址低于先定义的变量，比如上面代码中变量 s 的地址小于变量 b 的地址，p2 地址小于 s 的地址。栈中存储的数据的生命周期随着函数的执行完成而结束。