发布日期:2015-12-07 16:33 来源: 标签: 编程语言 C++教程 C++变量 C++入门
本章我们主要学习C++中局部变量、全局变量、变量类型等变量的相关知识,下面我们就做一下具体讲解,希望大家多多支持中国站长网络学院。
#include <iostream.h>
int a=10;
void main(void)
{  int a=20;  
   a=a+::a;
   {int a=50;::a=::a+a;}
   cout<<a<<'\t'<<::a<<endl;
}
(1)块
块是用花括号括起来的一部分程序。
(2)块作用域
在块内说明的变量具有块作用域,其作用域:从变量说明处到块的结束处(即块的右花括号处)。
C++语言规定:当程序块嵌套时,如果外层块中的变量与内层块中的变量同名,则在内层块执行时,外层块中的同名变量不起作用,即局部优先。 
文件作用域 
在函数外定义的变量(或用extern说明的变量)具有文件作用域。其作用域:从函数外定义变量的位置开始到该源程序文件结束(可用extern进行扩展)。
1.局部变量 
在函数或块内定义的变量称为局部变量,具有块作用域,假如函数同名,快内的变量不影响快外的变量。 
2.全局变量
定义在函数外的变量称为全局变量,具有文件作用域。 
注意:当具有块作用域的局部变量与具有文件作用域的全局变量同名时,与局部变量同名的全局变量不起作用,即局部变量优先。但与块嵌套不同的是,在块作用域内可通过作用域运算符“::”来引用与局部变量同名的全局变量。
全局变量、局部变量:局部变量优先(各有存储空间) 
局部变量、块内局部变量:块内局部变量优先(各有存储空间) 
变量类型
1.动态变量:在程序执行过程中分配存储空间的变量(new、malloc、快内局部变量auto、 register) 
2.静态变量:程序开始执行时就分配存储空间的变量 。
Auto、register类型的变量是动态局部变量,具有块作用域。只在块内有生命,脱离快无意义。
Int a; void qsh() extern int a;
Void qsh() {cout<<a<<endl;} void qsh()
{cout<<a<<endl;} int a; {cout<<a<<endl;}
Void main() void main() int a;
{} {} void main()
  Int a;这是全局变量,用它的时候得在函数前面定义,若是在函数后面或是来自外部文件的全局变量,必须使用extern 声明一下。
     “局部变量”存在于临时为函数分配的栈空间中,函数退出时该函数的栈帧被销毁,因此局部变量也不复存在,但“静态局部变量”与之不同,它存放在程序的数据段内,数据段是在进程启动系统为其开辟内存空间时就分配的一段专门存放数据的内存,在进程退出前一直存在,所以静态局部变量的数据能够一直保存。 
它们之间没有属于的关系,是存储方式完全不同的两种类型。 尽管它们都是写在函数内部的变量,作用域在局部,不可以在函数外部使用局部变量和静态局部变量,这是它们唯一的共同点。
      全局变量声明之前加上static,就是静态全局变量。全局变量和静态全局变量都是静态存储的;在存储上无区别。区别在于他们的作用域;全局变量的作用域是整个源程序,当源程序有多个源文件组成时,全局变量在各个源程序文件都是有效的;而静态全局变量怎被限制了作用域,只在定义该变量的源文件内有用在同一程序的其他源文件不能使用!还有静态全局变量/静态局部变量只初始化一次,防止在其他源文件调用!而全局变量可以再其他源文件初始化!!也就是说 全局变量可以在同一个源程序的其他cpp文件内使用,用时用extern声明一下;静态全局变量只能在此一个cpp文件内使用,不能用extern在外部cpp文件声明。
Extern 声明的全局变量等效于静态全局变量。
(1)静态局部变量在函数内定义,但不象自动变量那样,当调用时就存在,退出函数时就消失。静态局部变量始终存在着,也就是说它的生存期为整个源程序。   
(2)静态局部变量的生存期虽然为整个源程序,但是其作用域仍与自动变量相同,即只能在定义该变量的函数内使用该变量。退出该函数后, 尽管该变量还继续存在,但不能使用它。     
(3)对基本类型的静态局部变量若在说明时未赋以初值,则系统自动赋予0值。而对自动变量不赋初值,则其值是不定的。 
      根据静态局部变量的特点, 可以看出它是一种生存期为整个源文件的量。虽然离开定义它的函数后不能使用,但如再次调用定义它的函数时,它又可继续使用, 而且保存了前次被调用后留下的值。 因此,当多次调用一个函数且要求在调用之间保留某些变量的值时,可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的,但全局变量有时会造成意外的副作用(尤其是短名全局变量的变量名污染很严重),因此仍以采用局部静态变量为宜。 
简单的说静态局部变量与全局变量最明显的区别就在于:全局变量在其定义后所有函数都能用,但是静态局部变量只能在一个函数里面用.
1、变量的生存期
变量的生存期是指变量值保留的期限,可分为两种情况:
(1)静态存储:变量存储在内存中的静态存储区,在编译时就分配了存储空间,在整个程序运行期间,该变量占有固定的存储单元,变量的值都始终存在,程序结束后,这部分空间才释放。这类变量的生存期为整个程序。
(2)动态存储:变量存储在内存中的动态存储区,在程序运行过程中,只有当变量所在函数被调用时,编译系统临时为该变量分配一段内存单元,该变量有值,函数调用结束,变量值消失,这部分空间释放。我们说这类变量的生存期仅在函数调用期间。
2、变量的作用域
变量的作用域也称为可见性,指变量的有效范围,可分为局部与全局两种情况:
(1)局部变量:在一个函数或复合语句内定义的变量,称为局部变量,局部变量仅在定义它的函数或复合语句内有效。例如函数的形参是局部变量。
编译时,编译系统不为局部变量分配内存单元,而是在程序的运行中,当局部变量所在的函数被调用时,编译系统根据需要临时分配内存,调用结束,空间释放。
例:分析程序的运行结果。
func11( )
{ int x=3;
{ int x=2; /* 第一个复合语句中的局部变量 */
{ int x=1; /* 第二个复合语句中的局部变量 */
printf("*x=%d\n", x); 
}
printf("**x=%d\n", x);
}
printf("***x=%d\n", x);
}
main( )
{ int x=10;
printf("1: x=%d\n", x); 
func11( ); 
printf("2:x=%d\n", x); 
}
程序的运行结果是:
1: x=10 /* 输出主函数内的变量 x */
*x=1 /* 输出第一个复合语句中的变量x */
**x=2 /* 输出第二个复合语句中的变量x */
***x=3 /* 输出函数func11中的变量x */
2: x=10 /* 输出主函数内的变量x */
(2)全局变量:变量在所有函数之外定义称为全局变量,其作用范围为从定义开始,到本文件结束。全程变量一经定义,编译系统为其分配固定的内存单元,在程序运行的自始至终都占用固定单元。如果在定义之前使用该全局变量,用extern加以说明,则可扩展全局变量的作用域。
(3)使用全局变量与局部变量,应注意以下几点:
 ①不同函数内的局部变量可以重名,互不影响。
 ②全局变量与局部变量可以同名,在局部变量起作用的范围内,全局变量不起作用。
 ③全局变量的初始化只能有一次,是在对全局变量说明的时候。
例:分析以下程序的运行结果。
int x=100; /* 全局变量的定义 */
func12( )
{ int x=10; /* 局部变量,函数内有效 */
f( );
ff( );
printf("%d\n", x); 
}
f( )
{ int x=500; /* 局部变量,函数内有效 */
x += 100;
printf("%d\n", x);
}
ff( )
{ x += 100; /* 使用全局变量 */
printf ("%d\n", x);
}
程序运行结果: 600 /* 调用函数f( )的结果 */
200 /* 调用函数ff( )的结果 */
10 /* 函数func12( )的结果 */
自动变量
自动变量是最常见的一类变量,将变量的存储属性定义为自动变量的形式是: 
auto 类型说明符 变量名;
一般地说,不加说明的变量都属于自动变量,因此:
 auto int a; 等价于 int a;
 auto float b; 等价于 float b;
auto char str[100] 等价于 char str[100];
自动变量的说明必须在一个函数体的内部进行,函数的形参也是自动变量。自动变量的作用域是在所说明的函数中。
      自动变量实质上是一个函数内部的局部变量。只有该函数被调用时它才存在,从函数中返回时即消失,它们的值也仅限于说明它的函数,其它函数不能存取。自动变量随函数的引用与否而存在和消失,在两次调用之间自动变量不会保持变量值,因此每次调用函数时都必须首先为自动变量赋值后才能使用(参加运算)。如果不置初值,则变量的值为随机的不定值。 
由于自动变量具有局部性,所以在两个函数中可以分别使用同名的变量而互不影响。
例:分析程序打印结果:
main( )
{ int x=1; /* 函数main中的自动变量x */
    void f1( ), f2( );
   f1( ); f2(x); /* 分别调用函数f1和f2 */
printf ("x=%d\n", x);
}
void f1(void)
{ int x=3; /* 函数f1中的自动变量x */
printf ("x=%d\t", x);
}
void f2(x)
int x; /* 函数f2中的形参x也是自动变量 */
{ printf ("x=%d\t", ++x); /* x加1 */
}
 程序中有三个"x"分别在三个不同的函数中,这三个"x"都是自动变量,所以三个"x"分别局部于三不同的函数,在三个函数中对"x"的操作互不影响,故运行程序打印如下结果:
x=3 x=2 x=1
外部变量
外部变量的定义形式是:
extern 类型说明符 变量名;
所谓"外部"是相对于函数"内部"而言的,C语言的外部变量就是定义在所有函数之外的全局变量。它可以被所有的函数访问,在所有函数体的内部都是有效的,所以函数之间可以通过外部变量直接传递数据。
例: 分析程序运行结果。
#include <stdio.h>
int x; /* 说明外部变量x */
main( )
{ void addone( ), subone( );
x=1; /* 为外部变量x赋值 */
printf ("x begins is %d\n", x);
addone ( ); subone ( ); subone ( );
addone ( ); addone ( );
printf ("x winds up as %d\n", x);
}
void addone ( void )
{ x++; /* 使用外部变量x */
printf ("add 1 to make %d\n", x);
}
void subone(void)
{ x--; /* 使用外部变量x */
printf ("substract 1 to make %d\n", x);
}
  在程序的最前面语句"int x;"说明了变量x;该说明语句的位置在所有函数之外,所以变量"x"为外部变量,对函数main、addone和subone来说,变量x是全局变量,在这些函数的内部都是有效的。
函数addone和subone都是void型函数,它们没有返回值,没有形参。函数间的数据传递都是靠外部变量x进行的。执行程序中,main中将x赋值为1,调用addone函数,"x++"后x为2;调用subone时,"x--"后x为1,第二次调用subone函数,"x--"后x的值为0,分析程序运行过程可以得到程序的执行结果为:
x begins is 1
add 1 to make 2
substract 1 to make 1
substract 1 to make 0
add 1 to make 1
add 1 to make 2
x winds up as 2
      外部变量在编译的时侯由系统分配永久的存储空间。如果外部变量的说明与使用在同一个文件中,则在该文件中的函数在使用外部变量时,不需要再进行其它的说明,可以直接使用。当外部变量的说明与使用在两个不同的文件,要使用其它文件中说明的外部变量,就必须在使用该外部变量之前,使用"extern"存储类型说明符进行变量"外部"说明。
      "extern"仅仅是说明变量是"外部的",以及它的类型,并不真正分配存储空间。在将若干个文件连接生成一个完整的可运行程序时,系统会将不同文件中使用的同一外部变量连在一起,使用同一系统分配的存储单元。
      C语言中不仅有外部变量,而且有外部函数。由于C语言不允许在函数内部再定义函数,所以一个函数相对于另一函数本身就是外部的。当要调用的函数在另一个文件中时,在要调用的函数中,无论被调用的函数是什么类型,都必须用"extern"说明符说明被调用函数是"外部函数"。
例:下列程序由两个文件组成,请分析运行结果。
/* 文件一 */
int x = 10; /* 定义外部变量x和y */
int y = 10;
void add ( void )
{ y=10+x; x*=2;
}
main ( )
{ extern void sub( ); /* 在调用函数中说明函数sub是void型的外部函数 */
x += 5;
add( ); sub( ); /* 分别调用函数 */
printf ("x=%d; y=%d\n", x, y);
}
/* 文件二 */
void sub (void) /* 函数sub定义在另一个文件中 */
{ extern int x; /* 说明定义在另一个文件中的外部变量x */
x -= 5;
}
  程序由两个文件组成。文件一中说明两个外部变量x和y,main函数中调用了两个函数add和sub。其中函数sub不在文件一中,所以函数main中要使用"extern void sub()"语句说明函数sub是外部函数且无返回值;而函数add是在文件一中定义的,所以不必再进行说明。在文件二的函数sub中,要使用文件一中的外部变量x,所以函数sub中要用"extern int x"语句说明变量x是一个外部整型变量。程序编译后进行连接,文件一和文件二中的外部变量x会连接在一起,使用同一系统分配的存储单元。
运行程序,在main中执行语句"x+=5",即x=10+5=15;然后调用add函数执行"y=10+x",y=10+15=25,执行"x*=2",x=15*2=30;返回main函数后再调用sub函数,执行"x-=5",x=30-5=25。程序最终运行结果为:
x=25; y=25
例: 分析运行结果。
/* 文件一 */
int x=10; /* 说明外部变量x和y */
int y=10;
extern void sub( ); /* 在所有函数之外说明外部函数sub,则在每个调用外 */
/* 部函数sub的函数中,不再需要进行外部函数说明 */
void add(void)
{ int y=5; /* 说明自动变量y */
y=10+x; x *= 2;
printf("add:y=%d; ", y);
}
main ( )
{ x += 5;
add( ); sub( ); /* 分别调用函数 */
printf ("main:x=%d; main:y=%d\n", x, y);
}
/* 文件二 */
extern int x; /* 说明另一文件中的外部变量x */
void sub(void)
{ int y=5; /* 说明自动变量y */
x -= y;
printf("sub:y=%d; ", y);
}
   本程序与上例比较,在add函数内部使用"int y=5"语句说明了变量y。add函数内部的变量"y"与外部变量"y"不是同一变量。外部变量"y"是全局变量,在所有函数内部有效,而函数add中定义的变量"y"是自动变量,它局部于函数add本身。两个变量根本不同。由于函数add内部已经重新说明了同名的自动变量"y",所以外部变量"y"在函数add内部是不可见的,函数add不能再对外部变量y进行数据存取。所以在add内部"y=10+x"仅仅是修改了自动变量"y"的值,而对外部变量"y"的值无丝毫影响,同样在函数sub内部也定义了一个自动变量y。调用sub函数,执行"y=5",这时的"y"是sub内部定义的自动变量,它的值为5,与外部变量"y"没任何关系。在sub()执行语句中"x-=y"时的取值是自动变量y的值。所以程序运行结果为:
add:y=25; sub:y=5; main:x=25; main:y=10
  外部变量的特点,决定了它可以在函数之间传递数据。在程序设计中,函数与函数之间传递数据是通过函数的参数及函数的返回值实现,由于函数只能返回一个值,这就有一定的局限性,而外部变量不受数量的限制。但外部变量不宜过多,因为,一方面,外部变量始终占据内存单元,会使程序的运行受到一定的影响,另一方面,外部变量使得程序各模块之间牵连太多,当一个外部变量的值被误改的时候,会给后续模块带来意外的错误。
静态变量
静态变量是存放在内存中的静态存储区。编译系统为其分配固定的存储空间,重复使用时,变量的值保留。
静态变量定义的形式是:
static 类型标识符 变量名;
静态变量有两种:一种是外部静态变量,另一种是内部静态变量。
外部静态变量与外部变量有相似的地方,它是一种公用的全局变量,但作用域仅仅在定义它的那个文件中,出了该文件不管是否用extern说明都是不可见的。简单地讲,外部静态变量仅仅作用于定义它的一个文件,而外部变量作用于整个程序。
例: 分析下列程序的运行结果。
/* 文件一 */
static int x=2; /* 说明外部静态变量x */
int y=3; /* 说明外部变量y */
extern void add2( ); /* 说明外部函数add2 */
void add1( ); /* 说明函数add2,则在同一文件所有调用add1的函数中,
可以不再进行函数返回类型的说明 */
main ( )
{ add1( ); add2( ); add1( ); add2( );
printf ("x=%d; y=%d\n", x, y);
}
void add1(void) /* 定义函数add1 */
{ x += 2; y += 3;
printf ("in add1 x=%d\n", x);
}
/* 文件二 */
static int x=10; /* 说明外部静态变量x */
void add2 (void) /* 定义函数add2 */
{ extern int y; /* 说明另一个文件中的外部变量y */
x += 10; y += 2;
printf ("in add2 x=%d\n", x);
}
  程序的文件一中定义了外部静态变量x,它的作用域仅仅是文件一。外部变量y的作用域是整个程序。而在文件二中,定义了另一个外部静态变量x,它的作用域仅在第二个文件,它与文件一中的外部静态变量x毫无关系。
执行程序调用add1函数,x=x+2=2+2=4,y=y+3=3+3=6。调用add2函数,执行x+=10,此时add2中的x是文件二中的外部静态变量,所以x取值为10,x=x+10=10+10=20,而y为外部变量,y=y+2=6+2=8。再次调用add1函数,此时x=x+2应当是文件一的外部静态变量,x取值为4,x=x+2=4+2=6;执行y=y+3=8+3=11,再次调用add2执行语句x=x+10=20+10=30;执行语句y=y+2=11+2=13;所以打印结果为:
in add1 x=4
in add2 x=20
in add1 x=6
in add2 x=30
x=6; y=13
      内部静态变量与自动变量有相似之处。内部静态变量也是局限于一个特定的函数,出了定义它的函数,即使对于同一文件中的其它函数也是不可见的。但它又不象自动变量那样,仅当定义自动变量的函数被调用时才存在,退出函数调用就消失。内部静态变量是始终存在的,当函数被调用退出后,内部静态变量会保存数值,再次调用该函数时,以前调用时的数值仍然保留着。编译系统为函数的内部静态变量分配专用的永久性的存储单元。
例:分析下列程序的运行结果。
main ( )
{ void inc1( ), inc2( );
inc1( ); inc1( ); inc1( );
inc2( ); inc2( ); inc2( );
}
void inc1( )
{ int x=0; /* 说明自动变量x并赋初值 */
x++;
printf ("in inc1 x=%d\n", x);
}
void inc2( )
{ static int x=0; /* 说明内部静态变量x并初始化 */
x++;
printf ("in inc2 x=%d\n", x);
}
函数main分别三次调用函数inc1和inc2,在函数inc1中定义了自动变量x,在inc2中定义了内部静态变量x。连续三次调用inc1时,打印的结果一定为:
in inc1 x=1;
而三次调用inc2的结果就不一样了。第一次调用inc2,内部静态变量x=1;由于x为内部静态变量,故第二次调用inc2时,x仍保留第一次退出inc2时的值不变。所以第二次调用inc2,在inc2内部x=2,同理第三次调用inc2,在其内部x=3。程序运行结果为:
in inc1 x=1
in inc1 x=1
in inc1 x=1
in inc2 x=1
in inc2 x=2
in inc2 x=3
      要特别注意变量赋初值与初始化的区别。虽然inc2中第一个语句是"static int x=0",但它与语句"int x=0;"的含义是不一样的。对于自动变量来说,"int x=0;"的含义是对变量赋初值,该语句实际上等价于下列两个语句:
int x; /* 说明变量 */
x=0; /* 执行赋值操作为变量赋初值 */
为变量赋初值的操作要在函数被调用执行时才能进行。
     对于内部静态变量,"static int x=0"的含义是说明一个静态变量并进行初始化。初始化与赋初值不同,它是在程序运行之前,由编译程序一次性为变量赋的初值"x=0";而在实际运行时不用再执行赋值操作。
      在一般情况下,函数都是外部的,其名字在整个程序都是可见的。但也可以将函数说明为静态的,使它仅在定义它的文件内部有效。说明静态函数时,可在函数类型前加static进行限制。使用静态函数同外部静态变量一样,都可以保证其正确的作用域。
寄存器变量
     前面介绍的几种变量类型,都是保存在内存中,在程序运行时,根据需要到内存中相应的存储单元中调用,如果一个变量在程序中频繁使用,例如循环变量,那么,系统就必须多次访问内存中的该单元,影响程序的执行效率。因此,C语言还定义了一种变量,不是保存在内存上,而是直接存储在CPU中的寄存器中,这种变量称为寄存器变量。
寄存器变量的定义形式是:
register 类型标识符 变量名
 寄存器是与机器硬件密切相关的,不同类型的计算机,寄存器的数目是不一样的,通常为2到3个,对于在一个函数中说明的多于2到3个的寄存器变量,C编译程序会自动地将寄存器变量变为自动变量。 
由于受硬件寄存器长度的限制,所以寄存器变量只能是char、int或指针型。寄存器说明符只能用于说明函数中的变量和函数中的形参,因此不允许将外部变量或静态变量说明为"register"。
register型变量常用于作为循环控制变量,这是使用它的高速特点的最佳场合。
例:比较下面两个程序的运算速度。
/* 程序1 */
main ( )
{ register int temp, i;
for ( i=0; i<=30000; i++ )
for ( temp=0; temp<=100; temp++ ) ;
printf ("ok\n");
}
/* 程序2 */
#include <stdio.h>
main( )
{ int temp, i;
for ( i=0; i<=30000; i++ )
for ( temp=0; temp<=100; temp++ ) ;
printf ("ok\n");
}
这两个程序中,前者使用了两个寄存器变量,后者使用了两个自动变量程序除此之外完全一样。但运行时感觉的执行速度是不同的,前者使用寄存器变量的程序要比后者使用自动变量的程序要快。
(如果在Tubro C的环境下运行程序2,则应该将编译器优化选项"use register variable"开关关上(OFF),否则,编译器自动优化程序使用寄存器,两个程序会得到相同的结果。)
由于register变量使用的是硬件CPU中的寄存器,寄存器变量无地址,所以不能使用取地址运算符"&"求寄存器变量的地址。
变量存储类型的总结
对上述四种不同存储类型的变量,可以用表9-1总结。

变量规范命名规则
1.变量名只能是字母(A-Z,a-z)、数字(0-9)或下划线。 
2.第一个字母不能是数字,例如2Lerver这不是一个合法的C++变量。 
3.不能是c++关键字,例如不能用class这个单词来命名一个变量。 
4.区分大小写,例如iA和ia是两个不同的变量。 
理论上,在遵守了上面几条规则的前提下,所声明的变量名称都是合法的。比如下面的命名: 
char  xueshengming[20];    //学生名 
char  a;                   //命名一个字符,但变量名毫无意义 
这样的变量命名尽管是合法的,但可读性非常差。 
变量命名的宗旨: 
一、用最短的字符表示最多的意义。 
int iPosX;     //Pos表示位置,X表示横坐标 
//个人比较喜欢用n做前缀 
二、使用变量前缀 
在变量前带上小写前缀可以很直观的看出变量的数据类型,而不必到变量的定义处去查
看。常用的数据类型推荐变量前缀: 
1.整型的前缀 
short sValue;     //s为short的前缀 
int iAge;         //i为int的前缀 
unsigned int uiAge;   //ui为unsigned int的前缀(两个单词的首字母) 
//也有用u做前缀的 
long lValue;      //l为long的前缀 
2.浮点型的前缀 
float fScore;    //f为float的前缀 double dValue;   //d为double的前缀 
3.字符型的前缀 
char cChar;      //c为char的前缀 
//个人喜欢用a做前缀 
TCHAR tcChar      //多字节字符和Unicode字符兼容类型的前缀tc 
wchar_t  wcChar   //宽字符前缀wc 
4.字符串的前缀 
char szName[30];  //sz为C语言字符串的前缀 
string strName;   //str为C++字符串变量的前缀 
CString strInfo;  //str为MFC字符串变量的前缀 
5.布尔型的前缀 
bool bPass;      //b为bool的前缀 
6.指针型的前缀 
int *pValue;    //p为指针的前缀 
7.数组的前缀 
int arrNum[10];  //arr为数组的前缀 
string arrstrName[3];  //C++字符串数组,加上去似乎很别扭 
8.枚举变量的前缀 
enum  emWeek;    //em为枚举变量的前缀 
9.结构变量的前缀:t 
T_NODE  tNode;    //结构名称以T_开头 
10.字节变量的前缀:by 
BYTE  byInfo; 11.字变量的前缀 
DWORD  dwInfo;    //双字 
WORD    wInfo;    //单字 
12.字符指针的前缀 
LPCTSTR  ptszInfo;     //ptsz表示前缀,t表示TCHAR类型 
LPCSTR  pszInfo; 
LPSTR  pszInfo; 
13.STL容器类型前缀 
vector<int>  vecValue;   
说明:vec表示vector容器的前缀,为了简化变量,变量体后面不再使用前缀 
list<double>  lstInfo; 
14.MFC绑定控件变量的前缀 
CEdit  m_ctlName;      //对象变量,变量体前统一用ctl表示 
//个人喜欢用m_ctrl 
int    m_iAge;    //值变量,变量体有表示值数据类型的前缀 
15.矩形结构的前缀:rc 
RECT  rcClient;    
CRect  rcWin; 
16.句柄对象一律以h开头 
HWND hWndName; 
HBRUSH  hBr; 
HPEN  hPen; 
HBITMAP  hBmpBack; 
17.windows颜色类型的前缀:cr 
COLORREF crFront;    
18.windows中DC(设备上下文)类型的前缀 
CClientDC  dcClient; 
三、类的成员变量以m_开头,后面为变量体,变量体依然要有前缀。 int  m_iDepth; 
四、定义一个变量,为了简化,在不影响变量意义的情况下,可以仅仅使用前缀。 
RECT  rc; 
五、全局变量一律以g_开头,后面为变量体,变量体依然要有前缀。 
int  g_iNums; 
六、定义结构体为了保证和C语言和C++的写法兼容性,一律采用typedef语句。 
typedef   struct  tagINFO_NODE 

int  iData; 
tagINFO_NODE *pNext; 
}T_INFO_NODE, *PT_INFO_NODE; 
七、变量体如果是多个单词,每个单词的首字母大写。 
int iStudentAge; 
八、在意义明确的情况下可以仅仅使用首字母命名变量可以缩短变量名。 
int iID; 
说明:仅使用首字母表示变量体的前提是保证变量的意义,比如变量iStudentAge如
果声明成: 
int  iSA;         //这样将失去意义,不可取 
九、定义一个类使用C作为类名的前缀。 
class CStudent 

… 
}; 

相关评论

专题信息
    C++是在C语言的基础上开发的一种面向对象编程语言,应用广泛。C++支持多种编程范式 --面向对象编程、泛型编程和过程化编程。最新正式标准C++于2014年8月18日公布。 其编程领域众广,常用于系统开发,引擎开发等应用领域,是至今为止最受广大程序员受用的最强大编程语言之一,支持类:类、封装、重载等特性! 本教程从基础讲解了C++语言,希望对大家有所帮助,望多多支持中国站长网络学院。