int a=1;           //拥有自动生命期
auto int a=2;      //拥有自动生命期
static int a=3;    //延长了生命期

int a=1;
auto b=a;    //自动类型推断,b为int类型
cout<<typeid(b).name()<<endl;

std::vector<std::string> vs;
 
 
for(std::vector<std::string>::iterator i=vs.begin();i!=vs.end();i++){
 
}
相当于
for(auto i=vs.begin();i!=vs.end();i++){
 
}

template <typename _Tx,typename _Ty>
 
void Multiply(_Tx x,_Ty y){
 
    auto v=x*y;
    std::cout<<v;
}
 
auto Multiply(_Tx x,_Ty y)->decltype(x*y)
{
    return x*y;
}

void A(){
    
    //普通局部变量存储于进程栈空间,使用完毕后会立即释放
    //静态局部变量编译器会默认初始化为0,存储于进程的全局数据区,程序结束时释放
    static int a=1;
}

//全局变量本身就有内存的持久性,所以静态全局变量用于在其他源文件屏蔽该变量
 
//全局变量定义在函数体外部,在全局数据区分配存储空间,且编译器会自动对其初始化
//普通全局变量对整个工程可见,其他文件可以使用extern外部声明后直接使用,也就是说其他文件不能定义一个同名的变量
//静态全局变量仅对其当前文件可见,其他文件不可访问,其他文件可以拥有同名的变量
 
 
//file1.cpp
int varA;
static int varB;
 
//file2.cpp
extern int varA;        //使用其他源文件的全局变量
extern int varB;        //错误,静态全局变量被屏蔽
 

//非静态函数可以在另一个文件中直接引用不必加extern声明
//静态函数只能在声明它的文件中可见,其他文件不能引用该函数
//不同的文件可以使用相同名字的静态函数
 
//file1.cpp
 
extern void funA(){}
static void funB(){}
 
//file2.cpp
 
extern void funA();    //使用其他源文件的全局变量
extern void funB();    //错误,静态全局函数屏蔽了该函数

//静态成员可以独立访问,无须创建任何对象实例就可以访问
//静态成员变量每个class只有一份变量内存(全局数据区/静态区),而普通成员函数每个对象都有不同的变量内存
 
//test.h
class A{
    private:
        static const int a;
}
 
//test.cpp
const int A::a=1;    //不受private和protected访问限制

//类的静态成员函数无法调用类的非静态成员函数和变量,因为静态成员函数没有this指针
//类的非静态成员函数可以调用类的静态成员函数和变量
//静态成员函数不可以同时声明为virtual const volatile函数
 
class A{
    public:
        virtual static void fun1();    //错误
        static void fun2() const;      //错误
        static void fun2() volatile;   //错误
};