std::cout << "Count is " << count << std::endl;

在前面的学习中我们看到的输出没有 std::，而这一节出现了上面的代码。

std 是标准库函数使用的命名空间，是 standard（标准）的缩写。

using namespace std ，它声明了命名空间 std，后续如果有未指定命名空间的符号，那么默认使用 std，这样就可以使用 cin、cout、vector 等。

假设你不使用预处理 using namespace std;,就要加上 std::cin 或者 std::cout。

cin 用于从控制台获取用户输入，cout 用于将数据输出到控制台。

cin 是输入流对象，cout 是输出流对象，它们分别可以用 >> 和 <<，是因为分别在其类中对相应运算符进行了重载。

1.static 修饰类的成员变量

• 1). 静态成员变量是先于类的对象而存在
• 2). 这个类的所有对象共用一个静态成员
• 3). 如果静态成员是公有的，那么可以直接通过类名调用
• 4). 静态成员数据在声明时候类外初始化

#include <iostream>

using namespace std;
class Data
{
public:
    Data(){}
    ~Data(){}
    void show()
    {
        cout<<this->data<<" "<<number<<endl;
    }

    static void showData()//先于类的对象而存在
    {
        //这方法调用的时候不包含this指针
        cout<<" "<<number<<endl;
    }

private:
    int data;
public:
    static int number; //静态数据在声明时候类外初始化
};
int Data::number=0;//静态成员初始化

int main()
{
    Data::showData();//通过类名直接调用


    Data::number = 100;//通过类名直接使用
    Data d;
    d.show();
    d.showData();//通过对象调用

    cout << "Hello World!" << endl;
    return 0;
}

2.static 修饰类的成员方法

• 1). 静态成员函数是先于类的对象而存在
• 2). 可用类名直接调用（公有）
• 3). 在静态成员函数中没有this指针，所以不能使用非静态成员

const 修饰--常量 ---- const修饰的常量代替宏定义

修饰成员变量

const int data;

const 修饰的成员变量必须在构造方法的参数列表初始化（const static int pdata=10;除外）const 修饰的成员变量不能被修改

修饰成员方法

void showData()const{ }

const 修饰的成员函数中不能修改成员变量，不能调用非 const 修饰的函数

const 相比 #define 的优点：

1.const 常量有数据类型，而 #define 没有，编译器可以对前者进行类型安全检查，而对后者只能进行字符替换，没有安全检查，并且在字符替换时候可能导致意想不到的错误。

2.有些集成化的调试工具可以对 const 常量进行调试，但是不能对宏常量进行调试。

如何解决 g++ 不支持 auto 自动数据类型?

在编写 Lambda 表达式的时候，发现 gcc 似乎不支持 auto 类型。

源代码 test.cpp 如下:

#include <iostream>
using namespace std;
int main() {
        auto basicLambda = [] { cout << "Hello, world!" << endl; };
        basicLambda();
        return 0;
}

编译报错:

$ g++ test.cpp -o test
test.cpp: In function ‘int main()’:
test.cpp:6:7: error: ‘basicLambda’ does not name a type
  auto basicLambda = [] { cout << "Hello, world!" << endl; };
       ^
test.cpp:7:14: error: ‘basicLambda’ was not declared in this scope
  basicLambda();
              ^

经过查询，发现 gcc 是 4.8.4 版本，应该是默认不开启，但是可以通过添加编译参数 -std=c++11 解决问题，

$ g++ test.cpp --std=c++11 -o test
$ ./test
Hello, world!

在局部变量前加上“static”关键字，就成了静态局部变量。静态局部变量存放在内存的全局数据区。函数结束时，静态局部变量不会消失，每次该函数调用 时，也不会为其重新分配空间。它始终驻留在全局数据区，直到程序运行结束。静态局部变量的初始化与全局变量类似．如果不为其显式初始化，则C++自动为其 初始化为0。

静态局部变量与全局变量共享全局数据区，但静态局部变量只在定义它的函数中可见。静态局部变量与局部变量在存储位置上不同，使得其存在的时限也不同，导致对这两者操作 的运行结果也不同。

1、auto 可以根据对变量的赋值内容来决定变量的数据类型。

auto a=1; // 表示 int

2、函数 func 中的 static 保持局部变量 i 在函数间传递时值不会被重新初始化。即保留了局部变量的值。

#include <iostream>
 
// 函数声明 
void func(void);
 
static int count = 10; /* 全局变量 */
 
int main()
{
    while(count--)
    {
       func();
    }
    return 0;
}
// 函数定义
void func( void )
{
    static int i = 5; // 局部静态变量
    i++;
    std::cout << "变量 i 为 " << i ;
    std::cout << " , 变量 count 为 " << count << std::endl;
}

输出结果：

变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

假如 func 里面的 i 不是 static:

#include <iostream>
 
// 函数声明 
void func(void);
 
static int count = 10; /* 全局变量 */
 
int main()
{
    while(count--)
    {
       func();
    }
    return 0;
}
// 函数定义
void func( void )
{
    int i = 5; // 局部非静态变量
    i++;
    std::cout << "变量 i 为 " << i ;
    std::cout << " , 变量 count 为 " << count << std::endl;
}

输出结果：

变量 i 为 6 , 变量 count 为 9
变量 i 为 6 , 变量 count 为 8
变量 i 为 6 , 变量 count 为 7
变量 i 为 6 , 变量 count 为 6
变量 i 为 6 , 变量 count 为 5
变量 i 为 6 , 变量 count 为 4
变量 i 为 6 , 变量 count 为 3
变量 i 为 6 , 变量 count 为 2
变量 i 为 6 , 变量 count 为 1
变量 i 为 6 , 变量 count 为 0

主函数每次调用 func 函数，i 的值都被初始化为 5，因此执行 10 次的 i 的值都是 5+1=6。

3、extern关键字：用于不同文件之间的变量和函数的传递。

main.cpp：

#include <iostream>
 
int count ;//定义变量
extern void write_extern();//声明引用外部函数
 
int main()
{
   count = 5;//变量初始化
   write_extern();//调用外部函数
}
support.cpp

#include <iostream>
 
extern int count;//引用了外部变量count
 
void write_extern(void)//外部函数定义
{
   std::cout << "Count is " << count << std::endl;
}