c++易忘偏僻语法总结

╰+哭是因爲堅強的太久メ 2024-04-17 22:45 21阅读 0赞

# 一、static作用（修饰函数、局部变量、全局变量） #

转自： [http://www.cnblogs.com/stoneJin/archive/2011/09/21/2183313.html][http_www.cnblogs.com_stoneJin_archive_2011_09_21_2183313.html]

在C语言中，static的字面意思很容易把我们导入歧途，其实它的作用有三条。

（1）先来介绍它的第一条也是最重要的一条：隐藏。

当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话，我举例来说明。我们要同时编译两个源文件，一个是a.c，另一个是main.c。

下面是a.c的内容

char  a  =  ' A ' ;  //  global variable   
 void  msg()  
\{  
printf( " Hello\\n " );  
\}

下面是main.c的内容

int  main( void )  
\{  
 extern  char  a;  //  extern variable must be declared before use   
 printf( " %c  " , a);  
( void )msg();  
 return  0 ;  
\}

程序的运行结果是：

A Hello

你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使用？前面说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问。此例中，a是全局变量，msg是函数，并且都没有加static前缀，因此对于另外的源文件main.c是可见的。

如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。

（2）static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。虽然这种用法不常见，但我还是举一个例子。

\#include < stdio.h > 
 
 int fun( void )\{ 
 static int count = 10 ; // 事实上此赋值语句从来没有执行过 
 return count \-- ; 
\} 
 
 int count = 1 ; 
 
 int main( void ) 
\{ 
printf( " global\\t\\tlocal static\\n " ); 
 for (; count <= 10 ; \++ count) 
printf( " %d\\t\\t%d\\n " , count, fun()); 
 
 return 0 ; 
\}

程序的运行结果是：

global local static

1 10

2 9

3 8

4 7

5 6

6 5

7 4

8 3

9 2

10 1

（3）static的第三个作用是默认初始化为0。其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵，我们可以一个一个地把所有元素都置0，然后把不是0的几个元素赋值。如果定义成静态的，就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用，但又觉得每次在字符数组末尾加’\\0’太麻烦。如果把字符串定义成静态的，就省去了这个麻烦，因为那里本来就是’\\0’。不妨做个小实验验证一下。

\#include < stdio.h > 
 
 int a; 
 
 int main( void ) 
\{ 
 int i; 
 static char str\[ 10 \]; 
 
printf( " integer: %d; string: (begin)%s(end) " , a, str); 
 
 return 0 ; 
\}

程序的运行结果如下

integer: 0; string: (begin)(end)

最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏，其次因为static变量存放在静态存储区，所以它具备持久性和默认值0。

以上内容出自博客园Mr. Write之手，写的相当清晰易懂，存档方便复习。原文地址：[http://www.cnblogs.com/dc10101/archive/2007/08/22/865556.html][http_www.cnblogs.com_dc10101_archive_2007_08_22_865556.html]

**下面是中兴通讯2012校招笔试题的一道问答题：**

**1. static全局变量与普通的全局变量有什么区别 ?**

**　**　全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。

全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。

这两者的区别在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

**　　**static全局变量只初使化一次，防止在其他文件单元中被引用;

**2. static局部变量和普通局部变量有什么区别 ？**

把局部变量改变为静态变量后是**改变了它的存储方式即改变了它的生存期**。把全局变量改变为静态变量后是改变了它的**作用域**，限制了它的使用范围。

static局部变量只被初始化一次，下一次依据上一次结果值；

**3. static函数与普通函数有什么区别？**

static函数与普通函数作用域不同,仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static修饰的函数)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件.

static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

# 二、关于switch语句中定义变量的问题 #

转自： [http://blog.sina.com.cn/s/blog\_64bb90270100rrfy.html][http_blog.sina.com.cn_s_blog_64bb90270100rrfy.html]

switch语句中定义变量

<table style="width:100%; table-layout:fixed"> 
 <tbody> 
 <tr> 
 <td> 
 <div> 
 switch内部的变量定义 
 核心提示： 在switch语句内定义一个变量的时候，如果不在一个语句块内，它作用域是直到遇到switch的"}"才结束的。 
 规律： 1、有default时，可在default中定义，而不需要{}。 
 2、无default时，可在最后一个case里定义，不不需要{}。 
 3、其他情况都需要{}。 
 说明：1，2情况都是特例，刚好正确的"利用"了switch语句的“}”。 
 =========================================================== 
 对于switch结构，只能在它的最后一个case标号或default标号后面定义变量，如： case true: // 下面代码会报错error:declaration precedes a case label, skipped by case false. string file_name=get_file_name(); break; case false: //... 制定这个规则是为了避免出现代码跳过变量的定义和初始化的情况。回顾变量的作用域，变量从它的定义点开始有效，直到它所在块结束为止。现在考虑如果在两个case标号之间定义变量会出现什么情况。该变量会在块结束之前一直存在。对于定义该变量的标号后面的其他case标号，它们所关联的代码都可以使用这个变量。如果switch从那些后续case标号开始执行，那么这个变量可能还未定义就要使用了。这种情况下，如果需要为某个特殊的case定义变量，则可以引入块语句，在该块语句中定义变量，从而保证这个变量在使用前被定义和初始化。 case true: { //加大括号下面代码就对了ok:declaration statement within a statement block string file_name=get_file_name(); //... } break; case false: //... 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

很实用的东西

# 三、拷贝构造函数运用时机只有3个： #

（1）明确用一个对象初始化另一个对象时，如Cdata day2(day1)或Cdata day2=day1。

要注意的是， **Cdata day2=day1语句是初始化语句，所以会调用拷贝构造函数，而day2=day1语句是赋值语句，不调用拷贝构造函数**，而是使用“=”等号运算符重载，如果类中没有显示的重载等号运算符，类会自动提供一个默认的等号运算符，它的功能仅仅是复杂两个类的成员变量。

另外，Cdata day2(day1)这一句不仅明确而且显示的调用了Cdata类的构造函数（对象名后面加小括号就是显示调用构造函数），因为拷贝构造函数也是属于构造函数，当然被调用了。

（2）对象作为函数的参数时，实参和形参之间的赋值，如fun(Cdata day)。

（3）当对象作为函数的返回值，创建一个临时对象（ **返回值对象复制给临时对象**，比如返回值是return day，而函数声明的返回类型即临时对象的类型是Cdate &类型）时。

# 四、指针数组和指向数组的指针-----以及字符串数组的蜕变 #

分析一下三个声明：

1：　　Cat FamilyOne\[500\];　　　　　　　　　　　　　FamilyOne 是一个500个CAT对象组成的数组；

2:　　 CAt \* FamilyTwo\[500\];　　　　　　　　　　　 FamilyTwo是一个500个指向的CAT的指针组成的数组（指针数组）；

3:　　 CAT \* FamilyThree = new CAT\[500\];　　　　 FamilyThree是一个指针指向由500个对象组成的数组。

字符串数组的“蜕变”：

1. char name\[10\] = \{'C', 'h', 'i', 'n', 'a', '\\0'\}; 　　-----> 2. char name\[10\] = \{"China"\};　　-----> 3. char name\[10\] = "China";

# 五、const用在易混淆的地方 #

char greeting[] = "Hello";
    char* p = greeting;                  //non-const pointer, non-const data
    const char* p = greeting;          //non-const pointer, const data
    char* const p = greeting;          //const pointer, non-const data
    const char* const p = greeting;  //const pointer, const data
    
    //const 虽然变化多端，但并不高深莫测。
    //如果关键字const出现在星号的左边，表示被指物是常量；
    //如果关键字const出现在星号的右边，表示指针自身是常量；
    //如果出现在星号两边，表示被指物和指针两者都是常量。
    
    
    //Effective Ｃ＋＋

# 六、指向数组的指针：int (\*ptr)\[3\] #

1、int(\*p)\[3\];------ptr为指向含3个元素的一维整形数组的指针变量（是指针）  
2、int \*p\[3\];-------定义指针数组p，该数组由3个指向整型数据的指针元素组成（是数组）  
3、int(\*)\[3\];--------实际上可以看作是一种数据类型。也就是第一个（int(\*p)\[3\]）中定义的p的数据类型  
其实你要看他到底是什么，就是要看他最先和谁结合。 比如1中p先与\*结合，那就说明p本质是一个指针；而2中p先与后面的\[3\]结合，说明他本质是一个数组。

另外，指向数组的指针可以如下定义：

CAT \* FamilyThree = new CAT\[500\];　　　　 FamilyThree是一个指针指向由500个对象组成的数组。

注意：复习指针概念，在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始的，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说改指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说了改指针的值是这块内存区域的首地址。

# 七、C++申请动态二维数组 #

**网友提问：**

\#include<iostream> 
using namespace std; 
int main() 
\{ 
int \*\*p; 
int m,n; 
cout << "请输入行数和列数:" << endl; 
cin >> m >> n; 
\*p = new int\[m\]; 
for(int i = 0;i <= m-1;i++) 
\{ 
p\[i\]=new int\[n\]; 
\} 
for(int row = 0;row <= m-1;row++) 
\{ 
for(int col = 0; col <= n-1;col++) 
\{ 
p\[row\]\[col\] = 0; 
\} 
\} 
for(int row = 0;row <= m-1;row++) 
\{ 
for(int col = 0; col <= n-1;col++) 
\{ 
cout << p\[row\]\[col\] << "\\t"; 
\} 
cout << "\\n"; 
\} 
 
system("pause"); 
return 0; 
\} 
差点忘了发代码 
我用指向指针的指针定义了二维数组。 
1，但是刚运行到第一个FOR循环的时候就出问题了. 
2，我改成手动的逐一申请（比如p\[0\]=NEW int\[5\],p\[1\]=new int\[5\]...) 
然后就没问题了，但运行到最后还是有问题 
3，如果我要DELETE释放，是不是要先释放\*p然后逐一释放p\[0~5\]?

**准确的回答：**

你好！ 
首先你的代码有两个问题： 
1、动态创建一维数组时，是p = new int\[m\]; 
因此动态创建二维数组时，应该是p = new int \*\[m\]; 而不是\*p = new int\[m\]; 你的程序运行到这一步出错。 
2、多次定义row，导致编译出错。 
另外，如果要释放指针，需要先把数组p中的指针依次delete，最后再释放p。 
 
最终代码如下： 
int main() 
\{ 
int \*\*p; 
int m,n; 
cout << "请输入行数和列数:" << endl; 
cin >> m >> n; 
p = new int \*\[m\];

//【上面这点最关键，好好体会，可以看出c++中二维数组数据结构默认有一个占内存空间的存储各行的地址列表】 
for(int i = 0;i <= m-1;i++) 
\{ 
p\[i\]=new int\[n\]; 
\} 
for(int row = 0;row <= m-1;row++) 
\{ 
for(int col = 0; col <= n-1;col++) 
\{ 
p\[row\]\[col\] = 0; 
\} 
\} 
for(row = 0;row <= m-1;row++) 
\{ 
for(int col = 0; col <= n-1;col++) 
\{ 
cout << p\[row\]\[col\] << "\\t"; 
\} 
cout << "\\n"; 
\} 
for(row = 0;row <= m-1;row++) 
\{ 
delete \[\] p\[row\]; 
\} 
delete p; 
system("pause"); 
return 0; 
\}

[http_www.cnblogs.com_stoneJin_archive_2011_09_21_2183313.html]: http://www.cnblogs.com/stoneJin/archive/2011/09/21/2183313.html
[http_www.cnblogs.com_dc10101_archive_2007_08_22_865556.html]: http://www.cnblogs.com/dc10101/archive/2007/08/22/865556.html
[http_blog.sina.com.cn_s_blog_64bb90270100rrfy.html]: http://blog.sina.com.cn/s/blog_64bb90270100rrfy.html