c++易忘偏僻语法总结

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

转自： 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

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

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

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

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

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

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

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

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

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

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

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

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

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

转自： http://blog.sina.com.cn/s/blog_64bb90270100rrfy.html

switch语句中定义变量

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: //...

很实用的东西

三、拷贝构造函数运用时机只有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;
}