C++学习笔记（1）

#if与#endif

条件编译
　　#if (comdition)
　　{//语句##；}
　　#endif
　　如果（comdition）为真， 也就是逻辑1的话，编译下面的语句，如果（comdition）为假，即逻辑0，则不编译下面的语句。例子如下：

　　#define DEBUG
　　#if DEBUG
　　Printf(“Value of i:%d\n”, i);
　　Printf(“Value of j:%d\n”, j);
　　#endif

　　格式：
　　#if 常量表达式
　　常量表达式为0时，预处理器删除#if 和#endif中间的代码
　　#if 会把没有定义过的标准符视做为0，　如果没有定义DEBUG, 则
　　测试#if DEBUG 会失败，但#if !DEBUG会成功。
　　可以用宏来定义文件名：

　　#if define(IA32)
　　#define CPU_FILE “ia32.h”
　　#elif defined(IA64)
　　#deifine CPU_FILE “ia64.h”
　　#elif defined(AMD64)
　　#define CPU_FILE “amd64.h”
　　#endif
　　#include CPU_FILE

　　还可以取消已经定义的宏：
　　#if defined VALUE // 检验VALUE是否被定义 ，如果被定义
　　#undef VALUE // 解除语句定义
　　#define VALUE 1000 // 重新定义VALUE 为1000
　　#endif
　　如果检验没有定义，可以这样写：
　　#ifndef VALUE // 如果VALUE没有被定义
　　#define VALUE 1000 // 定义VALUE 为1000
　　#endif
　　以上所用的宏中：
　　#undef为解除定义;
　　#ifndef是if not defined的缩写，也可以写成#if !defined 即如果没有定义;
　　#ifdef是if defined的缩写，也可以写成#if defined 即检查是否定义过;
　　#ifdef 和 #if defined 的区别，#ifndef 与#if !defined 的区别相类似，都在于后者可以组成复杂的预编译条件，前者只判断单个宏是否定义,例如：

　　#if defined(PERL_PACK_CAN_SHRIEKSIGN)
　　/* v */ SIZE16,
　　#else
　　0,
　　#endif
　　#ifdef PERL_PACK_CAN_SHRIEKSIGN
　　/* v */ SIZE16,
　　#else
　　0,
　　#endif

　　#ifdef是种简写，但不支持更复杂的表达式。
　　#ifdef HAVE_MYHEADER
　　# if VERSION > 3
　　…
　　# endif
　　#endif
　　这种情况用
　　#if defined(HAVE_MYHEADER) && VERSION > 3
　　…
　　#endif
　　更为合理

typedef声明

可以使用typedef来定义已有变量类型的新的名字：
typedef int adc;
则abc qwe;
就等价于int qwe；
这个的应用和
typedef struct{} abc；是一样的，
在这里就表示把struct{}中的部分定义一个名称是abc；

枚举-enum 变量类型名{…} [枚举变量]

enum names{a,s,d,f};
enum names name;（enum names 某种意义上来说与int意义相当）
name=a;(或者是name=s;name=d,name=f,enum name如果name=m，那么编译的时候会报错)
enum中的变量的值如果没有赋值，默认从0开始，而且值都是整数（正数或者负数，0）都可以
如果其中一个变量赋值，后面的依次加1，赋值前面的依然是从0开始
例如：

#include <iostream>
using namespace std;
enum names{a,s=4,d,f=9,g}; 
int main ()
{
   enum names name=a;
   switch(name)
    {
      case(a):cout << a << endl;//break;
      case(s):cout << s<< endl;//break;
      case(d):cout << d << endl;//break;
      case(f):cout << f << endl;//break;
      case(g):cout << g << endl;//break;
    }
return 0;
}

则输出是

0
4
5
9
10

注意：当使用enum 变量的时候，声明是enum XXX xxx这种类型,并且后面不能忘记“;”

C++中变量的名称是区分大小写的

例如int a; 和int A;是两个不同的变量a和A;

变量的类型间是可以互相转换的，转换又分为自动转换和强制转换。

自动转换规则： 1、若参与运算量的类型不同，则先转换成同一类型，然后进行运算。 2、转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算.

a.若两种类型的字节数不同，转换成字节数高的类型

b、若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型

3、所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。

4、char型和short型参与运算时，必须先转换成int型。

5、在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。 :

int a = 1;
double b = 2.1;
cout << "a + b = " << a + b << endl;  //输出为a + b = 3.1

强制转换规则：

强制类型转换是通过类型转换运算来实现的。其一般形式为：（类型说明符）（表达式）其功能是把表达式的运算结果强制转换成类型说明符所表示的类型

int a = 1;
double b = 2.1;
cout << "a + b = " << a + (int)b << endl;  //输出为a + b = 3

系统变量与全局变量

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。
一个函数中的局部变量的作用范围只限于函数中，函数外仍然是局部变量
下面是一个实例：

#include <iostream>
using namespace std;

// 全局变量声明
int g = 20;

int main ()
{
  // 局部变量声明
  int g = 10;

  cout << g;

  return 0;
}

输出的结果是

10

当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值

变量名称	系统初始值
int	0
char	“\0”
float	0
doubile	0
pointer	NULL

常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。
整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
例子

#include <iostream>
using namespace std;
int main ()
{
    int a=011;
  cout << a <<endl;
 return 0;
}

则输出的是

9

#define

定义的是全局变量，如果在main函数之外定义（注意句尾没有“;”）,那么就相当与一个全局变量，那么就能够在子函数中使用，一旦使用#define，那么就不能够在子函数中再定义相同的变量名称。
注意，语句结束之后没有“;”

const

可以使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

定义成 const 后的常量，程序对其中只能读不能修改。
以下程序是错误的，因为开头就已经固定了常量，便不能再对其进行赋值：

#include <iostream>
using namespace std;
int main()
{
    const double pi;                      //圆周率的值用pi表示
    pi=3.14159265;
    cout<<"圆周率的近似值是"<<pi<<endl;
    return 0;
}

正确的方法：

#include <iostream>
using namespace std;
int main()
{
    const double pi=3.141592;            //圆周率的值用pi表示
    cout<<"圆周率的近似值是"<<pi<<endl;
    return 0;
}

#define定义的变量在子函数中仍然是全局变量，但是const就相当于普通的变量，定义域只在定义的函数中有效。
注意const使用的时候，除非遇到extern，其他都要成立
例子：

#include <iostream>
using namespace std;
#define USE 1000
extern const int A;   //正确，使用extern的外部变量。
const int B; //错误，没有初始化
void test()
{  
  // int USE=10;
   cout << USE+1<<endl;
}
int main ()

{
   int A=10; //正确第一次定义
    cout  <<  A  <<  endl;

    int A=11;  //错误，不能够更改定义过之后的A的值
cout  <<  A  <<  endl;
    test();

    return 0;
}