//main.cppint a = 0; 全局初始化区char *p1; 全局未初始化区main(){int b;// 栈char s[] = "abc"; //栈char *p2; //栈char *p3 = "123456"; 123456\0";//在常量区，p3在栈上。static int c =0； //全局（静态）初始化区p1 = (char *)malloc(10);p2 = (char *)malloc(20);//分配得来得10和20字节的区域就在堆区。strcpy(p1, "123456"); //123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。}

C++变量根据定义位置的不同，具有不同的作用域，作用域可分为6种：全局作用域，局部作用域，语句作用域，类作用域，命名作用域和文件作用域。

（三）、从作用域看

全局变量具有全局作用域

全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包括全局变量定义的源文件需要用extern关键字再次声明这个全局变量。

静态局部变量具有局部作用域

它只被初始化一次，自从第一次初始化直到程序与你新内阁结束都一直存在，他和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。

局部变量也只有局部作用域

他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用结束后，变量就被撤销，其所占用的内存也被收回。

静态全局变量也具有全局作用域

他与全局变量的区别在于如果程序包含多个文件的话，他作用于定义它的文件里，不能作用到其他文件里，即被static关键字修饰过的变量具有文件作用域。这样即使两个不同的源文件都定义了相同的静态全局变量，他们也是不同的变量。

（四）、从分配内存空间看

全局变量、静态局部变量、静态全局变量都在静态存储区分配空间，而局部变量在栈分配空间。

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

1、静态变量会被放在程序的静态数据存储区里，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是他与堆栈变量和堆变量的区别

2、变量用static告知编译器，自己仅仅在变量的作用域范围内可见。这一点是他与全局变量的区别。

从以上分析可以看出，把局部变量改变为静态变量后是改变了他的存储方式，即改变了他的生存期。把全局变量改变为静态变量后是改变了他的作用域，限制了他的使用范围，因此static这个说明符在不同的地方起的作用是不同的。

TIPS：

1、若全局变量仅在单个文件中访问，则可以讲这个变量修改为静态全局变量。

2、若全局变量仅在单个函数中使用，则可以将这个变量修改为该函数的静态局部变量。

3、全局变量、静态局部变量、静态全局变量都存放在静态数据存储区。

4、函数中必须要使用static变量的情况：当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

main()是省略了返回值类型，C语言会默认认为成main的类型为int，在main()的函数体内要返回一个值，如return 0; 而void main()的返回值是void类型，也就是说没有返回值。这样在main()的函数体内你就不用写return 0；或者return 1；之类的返回语句。

在一个程序中，可以说你看不出两者的差别，因为main()是C语言的入口点，入口点如果返回了程序也就结束了，因此C语言的这个特性似乎没用。可没用的话，C语言的设计者为什么要这么做呢？！肯定有用。

没错，前面我说的是在一个程序中，它似乎没用。可如果一个程序prog2调用另一个程序prog1的话（这里指的是prog2直接调用prog1编译好的可执行文件），那么这个特性就有用了。因为prog2要知道prog1运行之后的状态。比如你用C写了一个删除文件的程序（暂且命名为delf），然后用另一个程序去调用delf，那么调用结果怎么样啊？这个文件是否删掉了？这是int main()就会派上用场了。C语言中默认的main如果返回为0，那么这个程序调用就成功了，其他值，则为不同的错误代码。在你的delf程序中，如果那个文件删除成功，那么就在int main()中返回0，其他调用delf的程序就知道，噢，这个操作成功了。

在unix/linux系统中的很多命令都是通过这种方式获得运行结果的。

void main(int argc, char** argv)

这个函数搞个两星号，看上去比较复杂,但是如果改成这样就感觉熟悉的了许多void main(int argc, char* argv[ ]).

void main(int argc, char* argv[ ]) == void main(int argc, char* *argv)

这行中有三个字符串分别为 cp.exe doc1.txt doc2.txt

则argc为3，即argc是命令行中参数的个数。

char *argv[]为一个指像字符串的数组。

argv[0]="cp.exe"

argv[1]="doc1.txt"

argv[2]="doc2.txt"

agv[0]为一个字符串指针，它就象 *p=”goodbye”  实际上是*argv[0]=”cp.exe”

p为goodbye的首地址，*p则指向goodbye的第一个字符， *p=”goodbye”与p[ ]=”goodbye”完全致的作用, 同理argv[0]就指向cp.exe的地址，*argv[0]指向cp.exe的第一个字符，即c。

再如下一个文件为test.c的文件

＃include <stdio.h>
＃include <unistd.h>
＃include <string.h>int main(int argc, char **argv)
{   //用 gcc –o a test.c  然后执行 ./a  12345,以下为原程序和执行结果
char *p="goodbye";
char *p1[2]={"hello!!!!!!!","world"};printf("%s\n",p); // goodbyeprintf("%c\n",*p);//  gprintf("%s\n",p1[0]); // hello!!!!!!!printf("%s\n",p1[1]); // worldprintf("%s\n",argv[0]);//  ./aprintf("%s\n",argv[1]);//  12345}在你运行程序以后，操作系统会自动将参数传给你。
例如你编译好的程序叫做program.exe
你运行 program a b
这个时候，argc = 3
argv[0] = "program"
argv[1] = "a"
argv[2] = "b"

第十二问 const的用法

const用法主要是防止定义的对象再次被修改,定义对象变量时要初始化变量。

下面我就介绍一下几种常见的用法

1.用于定义常量变量,这样这个变量在后面就不可以再被修改

const int Val = 10;//Val = 20; //错误,不可被修改

2. 保护传参时参数不被修改,如果使用引用传递参数或按地址传递参数给一个函数,在这个函数里这个参数的值若被修改,则函数外部传进来的变量的值也发生改变,若想保护传进来的变量不被修改,可以使用const保护

void  fun1(const int &val){//val = 10; //出错
}
void fun2(int &val)
{val = 10; //没有出错
}
void main()
{int a = 2;int b = 2;fun1(a); //因为出错,这个函数结束时a的值还是2fun2(b);//因为没有出错,函数结束时b的值为10
}

如果只想把值传给函数,而且这个不能被修改,则可以使用const保护变量,有人会问为什么不按值传递,按值传递还需要把这个值复制一遍,而引用不需要,使用引用是为了提高效率，如果按值传递的话,没必要加const,那样根本没意义。

3. 节约内存空间

#define  PI  3.14 //使用#define宏const double Pi = 3.14 //使用const,这时候Pi并没有放入内存中double  a = Pi;  //这时候才为Pi分配内存,不过后面再有这样的定义也不会再分配内存double  b = PI;  //编译时分配内存double  c = Pi;  //不会再分配内存,double  d = PI;  //编译时再分配内存

const定义的变量,系统只为它分配一次内存,而使用#define定义的常量宏,能分配好多次,这样const就很节约空间。

4.类中使用const修饰函数防止修改非static类成员变量

class
{public:void fun() const //加const修饰{a = 10; //出错,不可修改非static变量b = 10; //对,可以修改
}private:int  a ;static int b;
}

5.修饰指针

const int *A; 或 int const *A;  //const修饰指向的对象，A可变，A指向的对象不可变
int *const A;              //const修饰指针A， A不可变，A指向的对象可变
const int *const A;           //指针A和A指向的对象都不可变

6.用const修饰函数的参数

6.1

如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const 修饰，否则该参数将失去输出功能。

6.2

const 只能修饰输入参数：

6.2.1如果输入参数采用“指针传递”，那么加const 修饰可以防止意外地改动该指针，起到保护作用

例如StringCopy 函数：

void StringCopy(char *strDestination, const char *strSource);

其中strSource 是输入参数，strDestination 是输出参数。给strSource 加上const修饰后，如果函数体内的语句试图改动strSource 的内容，编译器将指出错误。

6.2.2 如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。

例如不要将函数void Func1(int x) 写成void Func1(const int x)。同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。

6.2.3 对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比较低。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。

为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点：

“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A &a)。

以此类推，是否应将void Func(int x) 改写为void Func(const int &x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。

问题是如此的缠绵，我只好将“const &”修饰输入参数的用法总结一下。

对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。

对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。

7.用const 修饰函数的返回值

如果给以“指针传递”方式的函数返回值加const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。

例如函数：

const char * GetString(void);

如下语句将出现编译错误：

char *str = GetString();

正确的用法是

const char *str = GetString();

如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const 修饰没有任何价值。

例如不要把函数int GetInt(void) 写成const int GetInt(void)。

同理不要把函数A GetA(void) 写成const A GetA(void)，其中A 为用户自定义的数据类型。

如果返回值不是内部数据类型，将函数A GetA(void) 改写为const A & GetA(void)的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了，否则程序会出错。

函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。

例如：

class A
{  A & operate = (const A &other); // 赋值函数  };  A a, b, c; // a, b, c 为A 的对象  a = b = c; // 正常的链式赋值  (a = b) = c; // 不正常的链式赋值，但合法 

如果将赋值函数的返回值加const 修饰，那么该返回值的内容不允许被改动。上例中，语句 a = b = c 仍然正确，但是语句 (a = b) = c 则是非法的。

8.const 成员函数

--------------(const的作用：说明其不会修改数据成员)

任何不会修改数据成员的函数都应该声明为const 类型。如果在编写const 成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提高程序的健壮性。以下程序中，类stack 的成员函数GetCount 仅用于计数，从逻辑上讲GetCount 应当为const 函数。编译器将指出GetCount 函数中的错误。

class Stack  {  public:  void Push(int elem);  int Pop(void);  int GetCount(void) const; // const 成员函数  private:  int m_num;  int m_data[100];  };  int Stack::GetCount(void) const  {  ++m_num; // 编译错误，企图修改数据成员m_num  Pop(); // 编译错误，企图调用非const 函数  return m_num;  } 

const 成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。

关于Const函数的几点规则：

a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.

b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.

c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.

e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的。

对于这样的const function，关键词const到底影响了什么？下面用例子来说明。

class my {  public:
// ...  string& operator[](const string& s) const  { return table[s]; }  private:  map table;  }; 

上述重载的下标运算函数能否通过编译呢？不能（在mingw32 gcc3.4上）通过。给出了如下的错误提示：

passing `const std::map, std::allocator > >'

as `this' argument of `_Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with _Key = std::string, _Tp = std::string, _Compare = std::less, _Alloc = std::allocator >]' discards qualifiers

错误原因就在于，当本重载函数声明为const后，就只能调用其他的同样也声明为const的函数；而table[s]实际上调用的是map的下标重载运算函数，该函数并没有声明为const。所以去掉本函数的const声明，就可以顺利通过编译了。

下面再用一个小例子验证一下吧。

#include  #include
using namespace std;
class A{
public:  A(int n) { num = n; }  void incr() { num += 5; }  void disp() const  { cout << num ; }  int times(int m)  { return num * m; }  int f() const  {  incr();//passing `const A' as `this' argument of `void A::incr()' discards qualifiers  disp();// ok  times(2);//passing `const A' as `this' argument of `int A::times(int)' discards qualifiers  return num;  }  private: int num;  };  int main(int argc, char *argv[])  {  A a(5);  a.f();  system("PAUSE");  return EXIT_SUCCESS;  }  

const 函数只能调用 const 函数，即使某个函数本质上没有修改任何数据，但没有声明为const，也是不能被const函数调用的。

class Test
{  public :  int & GetValue()const;  private:  int value;
};  int &Test::GetValue() const  {  return value; //value此时具有const属性，与返回值类型int &的非const属性不匹配
}  

这样的代码在vs2003中提示的错误：error C2440: “return” : 无法从“const int”转换为“int &”。

在const函数中传递this的时候把this变成了const T* const this（个人理解）,所以一个非const的引用指向一个const类型的变量，就会error。

可以这样改，

1.把int value 改成mutable int value. mutable修饰的变量使之在const函数中可以被改变的。

2.return value 改成。 return const_cast(value)。const_cast去掉了const性质。

3.把函数写成const int &Test::GetValue() const ,.这样做的目的是使引用的变量也是const类型的，就相当于const int & b 。

4.把引用去掉，写成返回值类型的。

5.把函数后面的const去掉。

6.返回值不是类的成员变量。

int &Test::GetValue() const  {  int temp = value;  return temp;  } 

9.修饰类的成员变量

使用const修饰的变量必须初始化,在类中又不能在定义时初始化,

如;

class
{
private:int a = 10;const int b = 10;static const int c = 10;
//这样初始化都是错的,
}

下列关于const关键字的说法错误的是：

A用const常量代替宏定义可以让编译器进行安全性检查

B类的const成员函数不能修改类的成员变量，而且一个const类对象只能调用其const成员函数，不能调用非const成员函数

C  const成员函数与同名、同返回值、同参数列表的非const成员函数属于重载现象

D  推荐使用以下方面定义类成员数组： class A{ … const size_t SIZE=100; int _array[SIZE]; };                                                         【D】

初始化const int类型(没有static),在类的构造函数上初始化

Class Test
{
Public:Test():b(23) //构造函数上初始化b的值为23{
}
private:const int b ;
}初始化static const int这个类型的(带有static的)，在类的外面初始化
class Test
{
private:static const int c;
}
const int Test::c=10; //类的外部初始化c为10

10.const和static

成员函数都会在自己的形参表中加一个参数:这个参数是指向函数所在类的类型的CONST指针.比如:

class A
{private:int n;public:void set(){n=10;  };
};

上边的set函数，是给n赋值的，但是它怎么知道是给哪一个对象的n赋值呢？这就需要在参数中告诉它。编译器为我们作了这些工作。实际生成的set函数可以理解成这样的：

public A：：set（A* const this）

{

this-〉n=10；

}

而我们调用的时候其实是这样的：

A a；

A：：set（&a）；

理解这个对你理解你的这个问题很关键.如果是const成员函数，编译器所作的这项工作也会改变。它会生成一个指向cosnt对象的const指针。所以你不能通过this来改变它所指向的对象。但是要知道static对象并不需要this指针来改变，所以它和const函数是没关系的。

第十三问 逗号运算符

int main()
{
int a, b, c, d;
a = 3;
b = 5;
c = a, b;
d = (a, b);
printf("c=%d  ", c);
printf("d=%d\n", d);
}

C 语言中，逗号（,）也可以是运算符，称为逗号运算符（Comma Operator）。逗号运算符可以把两个以上（包含两个）的表达式连接成一个表达式，称为逗号表达式。其一般形式为：子表达式1, 子表达式2, ..., 子表达式n例如：a + b, c = b, c++
逗号运算符的优先级是所有运算符中级别最低的，通常配合 for 循环使用。逗号表达式最右边的子表达式的值即为逗号表达式的值。上例中，c++ 的值（c 自增之前的值）即为该表达式的值。逗号运算符保证左边的子表达式运算结束后才进行右边的子表达式的运算。也就是说，逗号运算符是一个序列点，其左边所有副作用都结束后，才对其右边的子表达式进行运算。因此，上例中，c 得到 b 的值后，才进行自增运算。

第十四问 sizeof

int main()
{
int i = 3;   int j;
j = sizeof(++i + ++i);
short m;    int n;     double dn;
int t = sizeof ( m + n);
int k = sizeof ( n + n);
int l = sizeof ( m);
int l2 = sizeof (m * m);
int l3 = sizeof (m + dn);
int l4 = sizeof (m + m);
printf("i=%d j=%d t=%d k=%d l=%d l2=%d l3=%d l4=%d\n", i,j,t,k,l,l2,l3,l4);
}

第十五问 传递

void f1(int*, int);
void (*p[2])(int*, int);
int main(void)
{int a = 3;  int b = 5;p[0] = f1;p[1] = f1;p[0](&a, b);printf("%d %d ", a, b);p[1](&a, b);printf("%d %d\n", a, b);return 0;
}
void f1(int *p, int q)
{int tmp = *p;   *p = q;   q = tmp;
}

第十六问 CPU进程与线程的关系和区别

几种进程通信方式

第十七问 链表的意义？链表与数组的区别？

第十八问 中断

第十九问 程序崩溃的原因