存储类别和类型限定词

存储类别 

五种类别：自动，寄存器，具有代码块作用域的静态，具有外部链接的静态，具有内部链接的静态。

链接：外部链接：文件作用域的变量。内部链接：static修饰的具有文件作用域的变量有内部链接)，

空链接：具有代码块作用域或者函数原型作用域的变量具有空链接 

<1>局部变量：函数内定义，函数内可见；

       全局变量（外部变量）：函数外定义，本源文件内可见。一般全局变量第一个字母大写

<2>动态存储方式：auto声明（动态变量） register（寄存器）   -----------------函数调用结束后存储空间释放

       静态存储方式：static声明的局部变量    (extern声明的)外部变量--------------在程序整个运行期间都不释放

<3>用static声明局部变量：函数调用结束后不丢失而保留原值。

<4>register变量：只有局部动态变量和形参可以作为寄存器变量，快速存储时使用。register long i;寄存器变量的地址无法获得；如果有多余的寄存器，将i优先放到寄存器中，加快执行速度。

<5>用extern声明外部变量：

  在多个文件内声明外部变量：在a.c文件中定义具有外部链接的静态变量Num，而在另一文件中用extern对Num作“外部变量声明(extern Num)。该声明常被放在定义该变量的C文件的配套的头文件中。a.c文件中的外部函数也可以声明来提高程序的可读性。

<6>用static声明外部变量：只限于被本文件使用，而不能被其他文件使用。

  

类型限定词

1，const

http://blog.csdn.net/welcome_ck/article/details/227964

<1>对全局数据使用const，保护数据，可以有const变量，数组和结构。

　          const int a=2;   int const a=2;

　　const使全局变量具有内部链接特性，要使其具有外部链接特性则：

　　　　extern const int a;  //一般放在与定义该常量的.c文件对应的.h文件中

<2>修饰指针　　

const int *p=date; 或者 int const*p=date;
//指向常量的指针不能通过指针修改数值(常用作函数参量) *p=1;(不允许)  p[1]=2;(不允许) date[0]=1(允许)：  
int * const p=date; 
//p必须总是指向同一个地址，但所指向的值可变。
const int * const p=date;
//p必须总指向同一位置，所指位置存储的值也不能改变。

可以将常量或非常量的地址赋给指向常量的指针；不能把常量数据的地址（或const int *p1）赋给普通指针，因为可能通过新的指针改变const数据。 

<3>修饰引用
       C++中的引用本身就是常量，在定义的时候被初始化且不可再更新。const修饰的引用表示引用指向的对象不能被更新。其定义格式下：

　　       double i;    const double & v = i; //引用v指向的变量i是常量

<4>函数中使用const

      const修饰的指针做函数形参 :

　　　　 void fun(const STUD *student);  //表示指针student指向的内存不可在该函数内被改动

　　const修饰的引用做函数形参 :

　　　　void fun(const A& a);    //表示对象a不可以通过任何方式在该函数内被修改

　　cosnt修饰函数返回值 :

　　　　const int* fun();  //返回的指针所指向的内存不可变

　　　　int * const fun();  //返回的指针不可被更新       

<5>类中使用const：

#include <iostream>
using namespace std;

class A
{
public:
    A(int x, int y):value1(x),value2(y) { }  //只能在初始化列表中初始化
    void print() const;  //常成员函数
    void print();
private:
    const int value1;  // 成员常量不可被修改
    int value2;
    static const int value3; //可以在类声明外被初始化
};

void A::print() const
{
    cout<<"调用常成员函数:value1="<<value1<<", value2="<<value2<<", value3="<<value3<<endl;
}

void A::print() 
{
    cout<<"value1="<<value1<<", value2="<<value2<<", value3="<<value3<<endl;
}


const int A::value3 = 3;

void main()
{
    A a(1, 2);
    A const b(4, 5);

    a.print();
    b.print();
}

View Code

运行结果：

  　const修饰数据成员 :

　　　　必须初始化,可以通过初始化列表或用上面的方法

　　const修饰成员函数 :

　　　　常成员函数不允许修改对象的任何一个数据成员；常成员函数能够访问对象的常数据成员，而其他成员函数不可以。

　　常对象

　　　　定义：    const A a;  或 A cosnt a;   //在定义时被初始化

　　　　常对象的任何数据成员都不能被修改，常指针对象和常引用也是这样。

　　　　常对象的任何非const成员函数都不能被调用，因为任何非const函数都有修改数据成员的可能。

注意：

a，应尽量使用const修饰的指针或引用做函数形参，而不是const修饰的对象实例。

b，const作为函数重载参考的情况：const修饰的引用或指针做函数形参；常成员函数；用const修饰函数返回值。

c，除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

 

2，volatile

http://www.cnblogs.com/chio/archive/2007/11/24/970632.html

<1>volatile 变量是随时可能发生变化的，与volatile变量有关的运算，不要进行编译优化，以免出错。

<2>表示用volatile定义的变量会在程序外被改变,每次都必须从内存中读取，而不能把他放在cache或寄存器中重复使用。

volatile变量的例子：

1) 并行设备的硬件寄存器（如：状态寄存器） 
2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables) 
3) 多线程应用中被几个任务共享的变量 

说明：

<1>一个参数可以const和volatile

如：只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它

<2>一个指针可以是volatile 

不常见，如：当一个中服务子程序修该一个指向一个buffer的指针时。 

<3> 

volatile char a;   
        a=0; 
       while(!a){ 
//do some things;   
       }   
       doother(); 
   如果没有 volatile doother()不会被执行

 

3，restrict

只可用于修饰指针，并且该指针是访问一个数据对象唯一且初始的方式。

作用：

<1>告诉编译器，可以自由做一些有关优化的假定(这个不用关心)。

<2>告诉程序员使用满足restrict要求的参数。一般，编译器无法检查你是否遵循了这一限制。

//C99函数：把s2位置的n个字节复制到s1位置：

void *memcpy(void * restrict s1, const void *restrict s2, size_t n); 
//表明用户在使用这个函数时，s1，s2是相应数据的唯一访问方式，即要保证s1和s2所指向的n字节的空间没有重复。
void *memmove(void *s1, const void *s2, size_t n);
//允许重叠，该函数考虑到了数据重叠的情况，在复制数据时会避免在使用数据前就覆盖了数据。

 

随机函数：

//<stdlib.h>
rand()  //产生0~RAND_MAX范围内的整数；roll = rand()%6+1; roll为1~6之间的整数；使用该函数，每次重新执行时得到的随机数是一样的。

//<time.h>
srand((unsigned int)time(0));  //初始化种子
time()   //该函数可以返回系统时间，单位有系统决定，返回值为数值类型。

 

转载于:https://www.cnblogs.com/zhoutian220/p/3993590.html