const

#define MAX 2
#define SS(x, y)  x + y
//更好的写法是#define SS(x, y)  ((x) + (y))

int main() { 
  const int a = 3; //const object must be initialized if not extern  
  printf("result:%d\n", SS(a, a));//6 
  printf("result:%d\n", SS(a, a) * MAX);//9 

  return 0;
}

const 和#define定义常量的区别：(const 严格意义上不能叫常量)
const可以节省空间，避免不必要的内存分配。编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，
这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。
#define PI 3.14159 //常量宏
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......
double i=Pi; //此时为Pi分配内存，以后不再分配！
double I=PI; //编译期间进行宏替换，分配内存
double j=Pi; //没有内存分配
double J=PI; //再进行宏替换，又一次分配内存！
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。

#define可以定义类似函数宏，但const不行 

在Java中,const是作为保留字以备扩充,同样的保留字以备扩充还有goto. 
你可以用final关键字.final也可以用于声明方法或类,被声明为final的方法或类不能被继承

#include <stdlib.h> 
#include <stdio.h> 
#include <time.h> 

#define MAX 2
#define SS(x, y)  x + y

typedef struct _A {
    int id;
    char name[20];
    int age;
}A;


int main(void) 
{ 
    const int x = 3;
    //int const x = 3; //同上一行 a都不可改变
    //x = 5;  //compile error

    struct _A _a = {15, "cm", 12};//可以省略struct

    const A a1 = {2015, "cm", 12};
    A const a2 = {2015, "cm", 12};
//  a1.age = 10; // compile error
//  a2.age = 10; // compile error

    //--------------------------------------------------
    A a = {15, "cm", 12};
    A aa1= {15, "cm", 12};
    A aa2= {15, "cm", 12};
    A aa3= {15, "cm", 12};
    A aa4= {15, "cm", 12};

    const A* paa1 = &aa1;  //表示结构体(类似对象)A*不可变
//  paa1->age = 1;  //compile error
    aa1.age = 1;
    printf("paa1.age:%d\n", paa1->age);//1
    paa1 = &a;
    printf("aa1.age:%d\n", aa1.age);//1
    

    A const* paa2 = &aa2;  //表示*paa2（结构体）不可变,同const A* paa1 = &aa1;
//  paa2->age = 1;  //compile error
    paa2 = &a;

    A *const paa3 = &aa3; // paa3不可变
    paa3->age = 1;
//  paa3 = &a;  //compile error

    const A* const paa4 = &aa4; 
//  paa4->age = 1;  //compile error
//  paa4 = &a;      //compile error
    //pointe--------------------------------------end

    return 0; 
}

//C语言中参数传递方式：值传递（基本类型和结构体）和地址传递（指针和数组）
//上述code是针对结构体，使用基本类型（如int）结果也一样
//const修饰并不是绝对不可以改变的，可以用其他方式偷偷的改变,比如 const A* paa1 = &aa1; 
//这个对象不能通过*paa1来改变，但是可以通过aa1来改变.

 下面再举个例子来说明const的真正含义：

int main(void) 
{ 
    int a = 3;
    const int* p = &a;
    //*p = 4; //compile error
    a = 5;

    return 0; 
}

*p是不能改变，但是可以通过a来改变

const就是不允许使用当前声明的方式(*p)去改变地址或地址指向的内存。但是我们可以通过其它方式来改变.

 所以const定义的不是常量，它只是一个限定符，限定不能以某种方法来修改某个值

// 这二者都一样表示a不可变
const int a;
int const a;

//这二者都一样表示结构体A不可变
const int A;
int cosnt A;

const int* a;  // *a不可变
int const* a;  // *a不可变

int* const a;  // a不可变

const int* const a = &b; // a 和 *a都不可变，而且最好初始化

const int const* a; // 这个拆开就是const int* a; 和int const* a;都表示*a不可变，显然这种写法不太推荐