C++知识点.doc

一、C++标识符的命名规则
1. 所有标识符必须由一个字母(a~z或A~Z)或下划线(_)开头；
2. 标识符的其它部分可以用字母、下划线或数字(0~9)组成；
3. 大小写字母表示不同意义, 即代表不同的标识符，如前面的cout和Cout；
二、如何正确地声明变量及其初始化
2. C++中变量定义的格式:    
类型名  变量名1，变量名2，…，变量名n ； 如：int  num1, num2; 
（2.1）在C++中，每个变量在使用前必须被定义，以便编译器检查变量使用的合法性。变量定义只是给变量分配相应的空间。 
（2.2）C++允许在定义变量的同时给变量赋初值。变量未被赋值前，值为未知 
格式：  类型名 变量名 = 初值；或者：类型名 变量名（初值）； 
     如：int count = 0;   或   int count(0);  都是定义整型变量count，并为它赋初值0。 
可以给被定义的变量中的一部分变量赋初值，如：int sum = 0, count = 0, num; 
（2.3）一旦定义了一个变量，可以将一个常量赋给该变量。变量赋值过程是“覆盖”过程，用新值去替换旧值  如  int a;         a=123;   或  a = 0x123;  都是正确的    
（2.4）在C++中， 定义变量时没有赋初值，然后直接引用该变量是危险的！！！
3. 数据类型(data type)：数据的编码方式、值域和可执行的操作。数据类型包括两个方面：数据的取值范围、可用的操作。C/C++中的数据类型分为两大类：基本数据类型：整型、浮点型、字符型和布尔型构造数据类型：字符串、数组、结构、联合和枚举 
 （3.1）整型(int)：以补码形式存储。
基本型 int ；长整型long： long / long int            
（3.1.1）整数运算时要注意数据的表示范围。如整数用两个字节表示，正整数 32767 加 1 的结果为 -32768。这称为整数运算的溢出，系统不检查这样的错误，程序员必须自己保证程序中不出现这样的错误。 
（3.1.2）在某些应用中，不可能出现负数，则整型数中有一半的数值范围是被浪费的。因
此在C/C++中可以将所有的数都看成正整数，称为无符号数。
无符号数的定义：在各种整数类型前加上关键词unsigned，变成unsigned int,  unsigned short,  unsigned long  
（3.2） 实型：以浮点表示，操作类似于整型，浮点数无法精确表示。 
（3.2.1）浮点类型的分类： 
单精度 float ；双精度 double
（3.3）字符型（char）：存放一个字母或符号，占一个字节，存放的是字符的内码。可执行比较、连接等运算。具有双重属性：整数属性和字符属性，整数属性：字符类型即单字节的整数类,字符属性：数据值即为相应字符的 Ascii 码。
字符类型名：char。可分为可打印字符：小写字母、大写字母、数字、标点符号、空格等；非打印字符：换行和报警字符或响铃 等控制字符   
（3.4）布尔型(bool)： 只有“真”、“假”两个值。可执行判断运算。如 bool flag=true; 
（3.5）字符串（string）：是类类型，用双引号“ ”表示，可执行字符串比较，连接应用时要加 #include <string>如 string  str= “dfhdsf”; 

三、如何声明常量
4.常量：值的直接表示。如1、3、1.57、“A‟等,又称直接量。 
（4.1） 整型常量可用十进制、八进制和十六进制表示： 
如十进制： 123，  -234；八进制：  0123  十六进制：0x123, 0x3a2f 
（4.2）浮点数常量有两种表示法： 
（1）十进制表示：1.23 ， 3.14；  
（2）科学计数法：尾数e指数 123e2=12300   2.25e-3=0.00225 ； 注意：尾数不能为空，指数必须为整数    
（4.3）字符常量：”a‟, “S‟, ”2‟等用一对单引号括起来的数据。字符串常量用双引号 
（4.4）命名常量：为值指定一个描述性的文字，增加程序的可读性。
在C++语言中，用const修饰，如 const double PI =3.14; 见 PI即知3.14。注意一般变量名需大写，如PI。  
二、算术运算符号及其运行规则
a) 整数除整数
b) % 求模运算
5.算术运算符：+（加） -（减）  *（乘）  / （求商）  %（求余） 
（5.1）“-”可为二元运算符，也可为一元运算符，其余所有的算术运算符都是二元运算符。 
（5.2）优先级：高  *  /  %， 低  +  -- 
（5.3）整型与整型数运算，结果为整型，如 5 / 2 = 2 ；整型与浮点数运算，结果为浮点数，如5 / 2.0 = 2.5 ；字符与整型数运算，结果为整型；字符与浮点数运算，结果为浮点数。 浮点数与浮点数运算，结果为浮点数。
 “%”运算符：取余，其两边都必须是整型数。 
6.关系运算符：   >,     >=,     ==,     <=,     <,     !=  
（6.1） 优先级：高于赋值运算符，低于算术运算符。关系运算符内部：==和 ！=较低 
（6.2）关系表达式：用关系运算符将二个表达式连接起来称为关系表达式。关系表达式的结果是 true 或 false。“等于”运算符是由两个等号组成。常见的错误是在比较相等时用一个等号。==(相等)，=（赋值）  
7. 逻辑运算符 ：&& (and)        ||  (or)         !   (not)   
 （7.1）优先级： !  高于  关系运算符 高于  && 高于|| 
（7.2）逻辑表达式：由逻辑运算符连接起来的表达式,其结果为“真(true)”或“假(false)” 逻辑表达式在执行时，先处理左边。如左边已能决定此逻辑表达式的结果，则右边不执行。因此，在&& 逻辑表达式中，应把false可能性较大的条件放在左边，在||表达式中，应把true可能性较大的条件放在左边，这样可以减少程序执行的时间  
8．赋值运算符：= 的优先级比算术运算符低 
（8.1）赋值语句： 把一个值赋给一个变量。如x = y + z; x = 3.14;  赋值语句的左边是变量，右边是表达式。 
（8.2）赋值表达式格式：<变量> = <表达式>     如x = x + 2。 
作用：将右边的表达式的值存入左边的变量，整个表达式的值是右边的表达式的结果。 赋值运算符是右结合的 
（8.3）左值(lvalue)： 在C++中，能出现在赋值运算符左边的表达式称为左值 
右值（rvalue）：赋值运算符右边的表达式的值 
（8.4）赋值语句：赋值表达式后面加上分号。 
（8.5）将赋值表达式作为更大的表达式的一部分 。如：a = (x = 6) + (y = 7) 等价于分别将x 和 y 的值设为6 和 7，并将6和7相加，结果存于变量a  
（8.6）其他运算符与赋值运算符结合的运算符称为复合赋值运算符。 格式：变量 op= 表达式; 等价于：变量 = 变量 op 表达式; 
常用的复合赋值运算符有：+=，－=，*=，/=，%=  如： balance += deposit;  balance -= surcharge;  x /= 10; salary *=2;  
（8.7）赋值和运算时的自动类型转换，在进行赋值操作时，会发生类型转换，将取范围小的类型转为取值范围大的类型是安全的反之是不安全的，如果大类型的值在小类型能容纳的范围之内，则平安无事 
强制类型转换：
 ①（类型名）（表达式）；或类型名  （表达式）；如z = (double)x / y; 
   ②静态转换(static_cast)：用于编译器隐式执行的任何类型转换  
格式：转换类型<类型名> (表达式)   如   z = static_cast<double>(x) / y;  
1. 单个分号组成的语句成为空语句 
2. 用{ }括起来的一组语句称为复合语句。在逻辑上看成一个语句。
 v 复合语句可以放在任何单语句出现的地方。 
3. 在复合语句中可以定义变量，但必须定义在最前面。 
4. 逗号表达式语句格式：表达式1，表达式2，…,表达式n 
 v 逗号运算符的优先级是所有运算符中最低的 如a的初值为0，则表达式 a += 1, a += 2, a += 3, a += 4, a += 5的结果为 15  
5. 前置  ++i, ---i  (先执行i+1或i-1，再使用i值）
6.后置  i++, i---   (先使用i值,再执行i+1或i-1）   
If语句
c) 形式
d) 三种If语句的执行流程
9. 控制语句: 改变程序中语句的执行次序。
 (9.1)if语句: 
①两个分支：条件测试为true时所执行的程序块叫做then子句，条件为false时执行的语句叫做else子句。  
格式
( 1 )     if  （条件测试） 语句；即else语句可省略    格式
（2）    if  （条件测试） 语句1； else   语句2； 
    eg. if  (grade >= 60)   cout << “passed”;
 eg. if  (grade >= 60)   cout << “passed”;     
    else               cout << “failed”; 

（3）多分支语句：条件1为true时所执行的程序块1，条件1为false但满足条件2时执行的语句块2,。依次类推，条件n-1为false但满足条件n时执行else语句。常见的有  3分支语句：if—else if－else。  
    eg. if  (grade >= 90)        cout << “A”;     
   else if  (grade >= 80)    cout << “B”;       
 else if  (grade >= 70)    cout << “C”;     
   else if  (grade >= 60)    cout << “D”;    
   else                   cout <<”E”; 
（9.2）条件语句使用注意 
①条件的结果值应该是 true 或 false，它们是C++中bool类型的值 
②条件可为任意表达式，不一定是关系表达式。0 为false，非 0 为true。
 ③if 语句可以没有else子句。合理的缩排。 
④if语句的then子句和else子句含有if语句，称为if语句的嵌套。
 eg  if (x < 100) 
{  
if (x < 90)  语句1； 
else  if (x<80)  语句2；  
else      语句3；
  ｝ 
else 语句4； 
  ⑤歧义性：如最后一个else跟哪个if 配对.。
 eg   if (y != 0)  
        if (x != 0)   
result  = x / y;  
       else    cout<<“error :y == 0”<<endl; 
配对原则：每个else子句是和在它之前最近的一个没有else子句的if语句配对。
 ⑥在每个if-else语句后加一对大括号｛ ｝是一种良好习惯，特别是有两个以上的复合语句需要执行时。  
（9.2）条件表达式：作用：更加简练的用来表达条件执行的机制  
？：运算符 ：问号冒号运算符      
 形式 ： (条件) ? 表达式1 : 表达式2   eg: max = x > y ? x :y; 

循环语句
e) 形式
f) 三种循环语句的区别
g) 三种循环语句的执行流程

10.循环语句：一个完整的循环结构一般由四部分组成： 
（10.1）For 语句：主要用于计数循环 
v 格式：for（表达式1；表达式2；表达式3）  语句；or｛语句快;｝ 
可以理解为:for(循环变量赋初值；循环条件；循环变量增值) 
   符合循环条件时的执行语句 
v 循环体可以是复合语句或空语句。 
v 循环里所有语句的一次完全执行称为一个循环周期。  
v 执行过程：先执行表达式1，再执行判断表达式2，如果为true，执行一次循环体
（即一个循环周期），接着执行表达式3，然后重新执行判断表达式2，若为true,又执行一次循环体，重复直至判断表达式2为false,，最后跳出整个循环。若开始执行条件表示2为false, 循环体一次也不执行。 
v For循环的三个表达式可以是任意表达式。三个表达式都是可选的。 
v 如果循环不需要任何初始化工作，则表达式1可以缺省。如循环前需要做多个初始
化工作，可以将多个初始化工作组合成一个逗号表达式，作为表达式1。 
如for (int i=0,; i<=10; ++i) ;
v 表达式2也不一定是关系表达式。它可以是逻辑表达式，甚至可以是算术表达式。
当表达式2是算术表达式时，只要表达式的值为非0，就执行循环体，表达式的值为0时退出循环。 
v 如果表达式2省略，即不判断循环条件，循环将无终止地进行下去。无终止的循环
称为“死循环” ，最简单的死循环是  for ( ;); 

（10.2）While语句： 与for循环等价，可相互代替。 
v 格式：while（表达式）  语句；or { 语句块；} 
v 执行过程：先计算出条件表达式的值。如果是false，循环终止；如果是true，整个
循环体将被执行，而后又回到while语句的第一行，再次对条件进行检查，若为true,接着执行循环体，重复直到条件为false,，跳出整个循环。 
v 用途：用于循环次数不定的循环。循环是否结束取决于某一个变量的值（标记控制重复） 
v 在for和while语句之后一般没有分号，有分号表示循环体就是分号之前的内容（空循环体）  
（10.3）   Do- While语句 
v 格式：  do语句；or { 语句块；} while (表达式)； 
v 执行过程：首先执行语句，然后判断表达式的值。如果表达式为0，继续向下执行，
否则，再次执行语句，再次判断表达式的值 
v 用途：用于至少执行一次的循环。注意后面有分号；  
11跳转语句： 
v break语句：跳出整个循环或switch语句。若有多重循环，跳出含break最近的循
环体。 
v continue语句：跳出当前本次循环，接着判断是否执行下次循环周期。  

12 几种典型的循环。注意格式及应用 
v 输入验证循环：以下两种等价，右边一个常用 
cout <<"请输入半径:"; //提示输入  
 do{  cout <<“请输入半径:";
 cin>>radius;  
 area = PI * radius * radius  }                                  
 while ( radius < 0) ;// 当radius < 0，重复输入，直到>0                   
  2.while(true)  // 或while (1)                           
   for (   ) ｛                                                   
 cout << “输入一个正整数：";//提示用户并读入数据                                            
 cin >>num; 
 if (num == -1) break; // if (num==标志) 跳出;    
 sum += num;    //处理数据                    
   }         
  v   查询循环                                     
★累加循环 p=0; char ans;  
//用于用户响应                         
for(int i=1;i<=N;i++)   
{ cout <<"请输入半径:"; //提示输入                    
      p=p+i;        
  cin >> radius; 
         area = PI * radius * radius      }                
★累乘循环 : p=1 
         cout << "area = " <<area <<endl;          
         for(int i=1;i<=N;i++)         
  {cout << "do you again?"<<endl; //询问提示           
  p=p*i;           
 cin >>ans;  //询问输入 } 
while(ans == 'Y'|| ans == 'y'); //询问循环  
v 编译（compiler）：将高级语言的程序翻译成机器语言，分为解释执行，编译执行 
v 连接(link)：将目标程序与已有的其它目标程序连接起来，产生一个可执行的程序 
v 输出流是传给显示器的数据流，将变量或表达式的内容显示在显示器上  格式 
Ø 输出一个变量的值：cout << a； 
Ø 输出多个变量的值：cout << a << b << c； 
Ø 输出表达式的结果：cout << “Hello world\n” << endl  
Ø 上述情况的组合： cout << a << “+”<< b << “=”<< a+b << endl;  
v 键盘流入的数据流，将键盘输入的数据存入变量 
格式：  cin >>变量1 >> 变量2 >> … >> 变量n； 如 cin >> a; 
当程序执行到cin时会停下来等待用户的输入,后面一定是变量名，不可加引号  用户可以输入数据，用回车（↙）结束。  
当有多个输入数据时，一般用空白字符（空格、制表符和回车）分隔。  如：a为整型，d为double，则对应于cin >> a >>d，用户的输入可以为 12  13.2↙      or    12（tab键）13.2↙  or  12↙13.2↙   
 如何定义一个带默认值参数的函数
如何调用一个带默认值参数的函数
h) 参数使用默认值
i) 参数不使用默认值  
函数
v 过程单元是程序的基本单位。在过程化的语言中，过程单元就是程序中某个模块的
表示。在面向对象的语言中，过程单元说明对象对各种事件是如何响应的。 
v 每个程序都必须有一个名为main的函数，它是程序的入口。主程序由一个或多个
函数组成 
v 程序主体（主函数main（））：主要包含如下模块：(definition –input-proocess-ouput) 
(1)变量定义：为程序中的数据准备存储空间  ( declaration or definition) 
(2)输入阶段：接受所需输入的信息。
它由两部分组成：显示提示信息和接收输入(input) 
(3)计算阶段：完成所需的计算(process)
 (4)输出阶段：输出计算的结果(output) 
v 函数的主要构成：函数声明，函数定义，函数调用 
v 可以把函数想象成数学中的函数。如f(x)=2x 参数表是一组自变量x，返回类型是
函数值的类型; 函数声明就是设函数为f(x), 函数定义（函数头+函数体）就是函数表达式如2x,函数调用就是带值计算如f(2)=2×2。 
v 函数声明：类似于变量声明，所有函数在使用前必须被声明。又称函数的原型，功能：说明函数和外界的交流，反映函数调用的全部信息。 
包括下列内容：函数名，函数的参数类型，函数的返回类型 
它的形式为：  返回类型  函数名（参数表）； 
返回类型：是函数的输出值的类型, void 函数没有返回值 
函数名：是函数的名字。程序可以通过函数名执行函数体的语句 
参数表：是函数的输入, 无参数列表，可不写，但是括号必须有。参数表中的参数说明之间用“，”分开，每个参数说明可以是类型，也可以是类型后面再接一个参数名。如：int  max(int, int);   int  max(int a, int b);    int main(  )   v 函数定义：函数头+函数体，相当于一个小程序。 
函数头：说明函数和外界的交流，与函数声明一样，参数表要有形参，void除外 函数体：｛ 一系列独立的程序步骤;｝,必须定义在函数体最前面 
形式：返回类型  函数名（参数表）//函数头        
{    code here;   //函数体 
             } 
Eg : int max(int a, int b)         //函数定义       
  {   if (a > b) return(a);  
else return(b); 
        }  
v 函数调用形式: 函数名（实际参数表）;一般出现在主调函数中或其他调用函数中。        eg.  max( x ，y)； 
v 函数执行过程： 
（1） 在主程序中计算每个实际参数值。 
（2） 调用时将实际参数的值赋给对应的形式参数。在赋值的过程中完成自动类型转换。 
（3） 进入函数体依次执行函数体的每个语句，直到遇见return语句或函数体结束 
（4） 计算return后面的表达式的值，如果表达式的值与函数的返回类型不一致，则完成类型的转换。 
（5） 用函数的返回值置换函数，继续主程序的执行。 Eg      int max(int a, int b); //函数声明 
int  main( ) {  int x, y；
cin >> x >> y; 
cout << max(x + 5, y - 3);//函数调用 ｝ 
int max(int a, int b)  //函数定义 
{    if (a > b) return(a); else return(b); } 
v  注意： 
(1) 形式参数和实际参数的个数(number)、排列次序(order)、类型(type)要完全相同。 
 (2) 实际参数可以是常量、变量、表达式，甚至是另一个函数调用 
(3) 传递方式：值传递，执行函数调用时，将实参值传递给形参，并替换形参同名的实体 
(4) 值传递：函数获得了主调程序参数变量值的拷贝。被调程序可以改变这些拷贝，但这对主调程序的环境没有影响。 
（5）请注意：C++中不允许函数定义嵌套，即在函数定义中再定义一个函数是非法的。一个函数只能定义在别的函数的外部，函数定义之间都是平行的，互相独立的。   例如：下面的代码在主函数中非法嵌套了一个f（）函数定义： void main() { 
  void f()   { 
     //…  } }  
函数参数的传递比较： 
1.   按值传递 以按值传递方式进行参数传递的过程为：首先计算出实参表达式的值，接着给对应的形参变量分配一个存储空间，该空间的大小等于该形参类型的长度，然后把已求出的实参表达式的值一一存入到为形参变量分配的存储空间中，成为形参变量的初值，供被调用函数执行时使用。这种传递是把实参表达式的值传送给对应的形参变量，故称这种传递方式为“按值传递”。这种方式被调用函数本身不对（主调函数中）实参进行操作，也就是说，即使形参的值在函数中发生了变化（主调函数中）实参的值也完全不会受到影响，仍为调用前的值。  例：按值传递。  
void swap(int,int);//函数定义 void main() { 
  int a=3,b=4; 
  cout<<"a="<<a<<",b=“      <<b<<endl; 
  swap(a,b); //函数调用   cout<<"a="<<a<<",b="       <<b <<endl; }  
void swap(int x,int y)//函数定义 { 
 int t=x;  x=y;  y=t; }  
此程序的运行结果为：a=3,b=4 
a=3,b=4  
2.  地址传递  如果在函数定义时将形参的类型说明成指针，对这样的函数进行调用时就需要指定地址值形式的实参。这时的参数传递方式即为地址传递方式。这种地址传递与上述的按值传递不同，它把实参的存储地址传送给对应的形参，从而使得形参指针和实参指针指向同一个地址。因此，被调用函数中对形参指针所指向的地址中内容的任何改变都会影响到实参。  例：地址传递。  
void swap(int *x ,int *y);//函数声明 void main() { 
 int a=3,b=4; 
 cout<<"a="<<a<<",b=“     <<b<<endl;  swap(&a,&b);、、 
 cout<<"a="<<a<<",b=“     <<b<<endl; }  
void swap(int *x,int *y) { 
 int t=*x;  *x=*y;  *y=t; } 
 此程序的运行结果为：a=3,b=4 
a=4,b=3 
3. 引用传递 按值传递方式容易理解，但形参值的改变不能对实参产生影响；地址传递方式虽然可以使得形参的改变对相应的实参有效，但如果在函数中反复利用指针进行间接访问，会使程序容易产生错误且难以阅读。如果以引用作为参数，则既可以使得对形参的任何操作都能改变相应的实参的数据，又使函数调用显得方便、自然。引用传递方式是在函数定义时在形参前面加上引用运算符“&”。  例引用传递。  
void swap(int &,int &); void main() { 
 int a=3,b=4; 
 cout<<"a="<<a<<",b=“     <<b<<endl;  swap(a,b); 
 cout<<"a="<<a<<",b=“     <<b<<endl; } 
void swap(int &x,int &y) { 
 int t=x;  x=y;  y=t; } 
 此程序的运行结果为：a=3,b=4 
a=4,b=3 

函数的嵌套调用：   
     函数体   }由前述可知，C++函数不能嵌套定义，即一个函数不能在另一个函数体中进行定义。但在使用时，允许嵌套调用，即在调用一个函数的过程中又调用另一个函数。 例如： func1(int a, float b)    { float c; 
     c=func2(b-1,b+1);//嵌套调用,func1调用func2    }  
int func2(float x, float y)    {  //函数体   } 
//func1和func2是分别独立定义的函数，互不从属。

如何定义一个递归函数
j) 汉诺塔
k) 求最大公约数
l) 计算阶乘
函数的递归调用：   
一个函数直接或间接地调用自身，这种现象就是函数的递归调用。 
 递归调用有两种方式：直接递归调用和间接递归调用。直接递归调用即在一个函数中调用自身，间接递归调用即在一个函数中调用了其他函数，而在该其他函数中又调用了本函数。  
 利用函数的递归调用，可将一个复杂问题分解为一个相对简单且可直接求解的子问题（“递推”阶段）；然后将这个子问题的结果逐层进行回代求值，最终求得原来复杂问题的解（“回归”阶段）。   例：求n的阶乘。（函数递归调用的例程。）  long f(int n) { if(n<0) 
 {cout<<“error!“      <<endl;     return(-1); } 
  else if(n<=1)         return(1);    else 
    return (n*f(n-1));//自己调用自己 } 
void main() 
{long f(int n);  int n; 
 cout<<"input n:"      <<endl;  cin>>n; 
 cout<<"n!="<<f(n)      <<endl; }  
此程序的运行结果为：please input n:5 
n!=120  

程序的内存区域： 
  一个程序将操作系统分配给其运行的内存块分为4个区域。 （1）代码区，存放程序的代码，即程序中各个函数中的代码块。 （2）全局数据区，存放程序全局数据和静态数据。 （3）堆区，存放程序的动态数据。 
（4）栈区，存放程序的局部数据，即各个函数中的数据。  

如何使用变量（变量的作用是什么?）

2.局部变量。 
 在一个函数内部说明的变量是内部变量，它只在该函数范围内有效。也就是说，只有在包含变量说明的函数内部，才能使用被说明的变量，在此函数之外就不能使用这些变量了。所以内部变量也称“局部变量”。 
关于局部变量的作用域还要说明以下几点： 
1．主函数main()中定义的内部变量，也只能在主函数中使用，其它函数不能使用。同时，主函数中也不能使用其它函数中定义的内部变量。因为主函数也是一个函数，与其它函数是平行关系。这一点是与其它语言不同的，应予以注意。 
2．形参变量也是内部变量，属于被调用函数；实参变量，则是调用函数的内部变量。 3．允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰，也不会发生混淆。 
4．在复合语句中也可定义变量，其作用域只在复合语句范围内。   
3.全局变量 
(1)在函数外部定义的变量称为外部变量。以此类推，在函数外部定义的数组就称为外部数
组。 
(2)外部变量不属于任何一个函数，其作用域是：从外部变量的定义位置开始，到本文件结束为止。 
(3)外部变量可被作用域内的所有函数直接引用，所以外部变量又称全局变量 对于全局变量还有以下几点说明： 
（1）外部变量可加强函数模块之间的数据联系，但又使这些函数依赖这些外部变量，因而使得这些函数的独立性降低。从模块化程序设计的观点来看这是不利的，因此不是非用不可时，不要使用外部变量。定义但不初始化，则自动赋以"０"（整型和实型）或'\0'（字符型） 
（2）在同一源文件中，允许外部变量和内部变量同名。在内部变量的作用域内，外部变量将被屏蔽而不起作用。 
（3）外部变量的作用域是从定义点到本文件结束。如果定义点之前的函数需要引用这些外部变量时，需要在函数内对被引用的外部变量进行说明。外部变量说明的一般形式为： extern  数据类型  外部变量[，外部变量2„„]；  
注意：外部变量的定义和外部变量的说明是两回事。外部变量的定义，必须在所有的函数之外，且只能定义一次。而外部变量的说明，出现在要使用该外部变量的函数内，而且可以出现多次。  
静态局部变量1.定义格式： static  数据类型  内部变量表； 2.存储特点 
(1)静态局部变量属于静态存储。在程序执行过程中，即使所在函数调用结束也不释放。换句话说，在程序执行期间，静态内部变量始终存在，但其它函数是不能引用它们的。 
(2)定义但不初始化，则自动赋以"０"（整型和实型）或'\0'（字符型）；且每次调用它们所在的函数时，不再重新赋初值，只是保留上次调用结束时的值！ (3)何时使用静态局部变量 
§需要保留函数上一次调用结束时的值。变量只被引用而不改变其值。  

一维数组
m) 如何正确地声明一维“静态”数组并初始化
i. 初始化列表的长度与数组大小的关系
ii. 数组大小必须是整型常量
n) 如何使用数组元素
i. 通过“索引值”访问数组中的具体元素
ii. 对“索引值”的说明（整型值、从0开始）
o) Josephus问题
p) 筛选质数

13.数组： 
v 数组是一组同类元素，它有两个特征：
Ø 数组元素是有序的 
Ø 数组元素是同类的 
v 定义数组要定义三个基本内容： 
Ø 数组名字 
Ø 数组元素的类型
 Ø 数组的大小 

v 定义格式： 
     类型   数组名[元素个数]； 
     其中，元素个数必须是常量。如：       int  intarray[10]; 
      但   int n=10;  int intarray[n];   是错的 
v 常用的方法是将元素个数定义为一个常量。如：      Const int NumOfElement=  10; 
     int  intarray[NumOfElement];  相当于 int  intarray[10]; 
v 声明数组时可以对数组初始化 
       float  x[5] = { -1.1, 0.2,  33.0, 4.4, 5.05 }; 
v 初始化表的长度短于要被初始化的数组元素数目，那么剩余元素被初始化为0。 v 带有初始化的数组可以不定义长度 
      int  a[]={1,2,3,4,5}; 则默认数组大小为5 
v 数组元素的使用是通过数组名及元素的序号来指定，如intarray[2]。当数组的大
小为n时，元素的序号为0 – n-1。 
v 元素的序号称为下标。程序中，下标可为整数、整型变量或结果为整型的任意表达
式 
v 定义数组就是定义了一块连续的空间，空间的大小等于元素数*每个元素所占的空
间大小。 
v 数组元素按序存放在这块空间中。 
v C++语言不检查数组下标的超界。如定义数组 int intarray[10]; 合法的下标范围
是0 – 9，但如果你引用intarray[10]，系统不会报错。如数组intarray 的起始地址是1000，则引用intarray[10]，则系统对1040号内存进行操作。而1040可能是另一个变量的地址 
v 解决方法：由程序员自己控制。在对下标变量进行操作前，先检查下标的合法性。 
v 由一系列字符组成的一个单元称为字符串  
v  
字符串： 
v 在C++中，字符串常量用一对双引号括起来。如”Hello,world”  v 字符串变量：用字符类型的数组来表示 
v 字符串的本质是一系列的有序字符，因此可以用一个字符数组来保存这组字符 。
用数组名表示这个字符串 
v 由于数组名是数组的起始地址，因此该字符串从该地址开始存储。但到哪里为止？
C++用‘\0’表示字符串的结束。 
v 字符串所需的存储空间比实际的字符串长度大1 
v 如要将字符串”Hello,world”保存在一个数组中 ，该数组的长度为12 
v C