C++01输入输出-名字空间

前言：更多内容请看总纲《嵌入式C/C++学习路》

#include  // 头文件变了

int main(void)
{
    // 在std名字空间的标准输出空间插入hello c++ 这个字符串  endl是换行符的意思
    std::cout << "Hello C++" << std::endl;  // std:: 两个冒号表示std的空间
    return 0;
}

从上面程序可以看到C与C++的区别为：

1. 编译器换成了g++，拓展名换成了.cpp
2. 头文件不再是而是，表示面向对象流。也可以用#include< cstdio >
3. 流操作：输出：cout<< 或 输入：cin >> , 也可以用scanf/printf
4. 所有标准类型，对象和湖南数都位于std命名空间中。

注意：也可以用gcc编译，但是后面要加上 -lstdc++，例如：

#include  // 头文件变了
#include   // 同stdio.h 只是用c++封装了

int main(void)  // void 代表没有形参
{
    // 在std名字空间的标准输出空间插入hello c++ 这个字符串  endl是换行符的意思
    std::cout << "Hello C++" << std::endl;
    printf("Hello cn");
    int a,b;
    std::cin >> a >> b;    // 输入,同scanf函数，这里变量前不用加&符号，而且c++会自动确定a,b的格式
    std::cout << a << ' ' << b << std::endl;  // 输出a,b用空格隔开

    return 0;
}

为什么需要名字空间？

1. 划分逻辑单元
2. 避免名字冲突

怎么定义名字空间？
格式： namespace { … }

怎么用名字空间？
跟std一样，后面加两个:: 例如 std::

#include 

// 定义两个名字空间abc 和 cbc分别代表两个银行，并且在里面实现存钱取钱，查询余额的功能
namespace abc   // abc银行
{
    float g_balance = 0.0; // abc的余额
    void save(float money) // 存钱
    {
        g_balance += money;
    }
    void draw(float money) // 取钱
    {
        g_balance -= money;
    }
    void show(void) // 查看还有多少钱
    {
        std::cout << g_balance << std::endl;
    }
}

namespace cbc   // cbc银行
{   
    float g_balance = 0.0; // cbc余额
    void save(float money) // 存钱
    {
        g_balance += money;
    }
    void draw(float money) // 取钱
    {
        g_balance -= money;
    }
    void show(void) // 查看还有多少钱
    {
        std::cout << g_balance << std::endl;
    }
}

int main(void)
{
    abc::save(10000); // 在abc银行存钱
    abc::draw(5000);
    abc::show();
    cbc::save(8000);  // 在cbc银行的存钱
    cbc::draw(2000);
    cbc::show();
    return 0;
}

（感觉名字空间有点像python的类，std::func()有点像 实例.方法）

在命名空间里面声明，在空间外面定义，但是函数名前要指定命名空间：

#include 


namespace abc
{
    void foo(void){
        std::cout << "abc::foo" << std::endl;
    }
    void bar(void); // 声明bar函数，该函数的定义在命名空间外面
}

void abc::bar(void){   // 定义的时候要在前面加上abc:: 代表作用域是abc名字空间，即该函数是abc的
    std::cout << "abc::bar" << std::endl;
}

int main(void)
{
    abc::bar();
    return 0;
}

由上述例子可以看到，利用 :: 可以调用名字空间的函数。但是该方法每次都要输入名字，比较麻烦。
有两种解决方法：1.名字空间指令 2. 名字空间声明

格式：
using namespace abc; // 该条指令以下的指令可以直接访问abc空间里面的函数或者变量，不用加 ::

#include 
namespace abc
{
    void foo(void){
        std::cout << "abc::foo" << std::endl;
    }
    void bar(void); // 声明bar函数，该函数的定义在命名空间外面
}

void abc::bar(void){   // 定义的时候要在前面加上abc:: 代表作用域是abc名字空间，即该函数是abc的
    std::cout << "abc::bar" << std::endl;
}

int main(void)
{
    using namespace abc;  // 名字空间指令
    foo();  // 直接调用abc空间里面的foo函数
    return 0;
}

还有一个好处就是，每次用cin cout的时候都要写std，所以使用
using namespace std后，后面可以直接调用cin cout

假如指向让abc空间里面的某一部分内容可以直接调用，可以这么写：
using abc::foo; // 下面的语句只可以直接调用abc空间的foo函数，不可以调用bar函数。报错如下：

#include 


namespace abc
{
    void foo(void){
        std::cout << "abc::foo" << std::endl;
    }
    void bar(void); // 声明bar函数，该函数的定义在命名空间外面
}

void abc::bar(void){   // 定义的时候要在前面加上abc:: 代表作用域是abc名字空间，即该函数是abc的
    std::cout << "abc::bar" << std::endl;
}

int main(void)
{
    using abc::foo;  // 名字空间声明
    foo();
  //  bar();
    return 0;
}

假如直接调用bar函数，直接报错：

1. 不属于任何有名名字空间的标识符，隶属于无名名字空间
2. 无名命名空间的成员，直接通过 :: 访问

#include 

int g_balance = 1234;  // 在外部定义一个变量

namespace abc   // abc银行
{
    float g_balance = 0.0; // 在内部定义一个变量 ，两个变量名字相同
    void save(float money) // 存钱
    {
        g_balance += money;
    }
    void draw(float money) // 取钱
    {
        g_balance -= money;
    }
    void show(void) // 查看还有多少钱
    {
        std::cout << g_balance << std::endl;
    }
}

int main(void)
{
    abc::show();  打印变量的大小
    return 0;
}

输出为0，可见，调用的是abc空间内部的g_balance变量。小的作用域覆盖大的作用域，就近原则。

如果想访问外面的g_balance变量，就用到了无名名字空间，代码修改如下：

#include 

int g_balance = 1234;

namespace abc   // abc银行
{
    float g_balance = 0.0; // abc的余额
    void save(float money) // 存钱
    {
        g_balance += money;
    }
    void draw(float money) // 取钱
    {
        g_balance -= money;
    }
    void show(void) // 查看还有多少钱
    {
        std::cout << g_balance << std::endl;
        std::cout << ::g_balance << std::endl;  // 无名名字空间，调用外面的g_balance
    }
}

int main(void)
{
    abc::show();
    return 0;
}

内层标识符隐藏外层同名标识符

嵌套的名字空间需要逐层分解 ，可通过名字空间别名简化书写，例如：

#include 

namespace ns1
{
    int x = 100;
    namespace ns2
    {
        int x = 200;
        namespace ns3
        {
            int x = 300;
        }
    }
}

int main(void)
{
    std::cout << ns1::x << std::endl;  // 打印ns1的x值
    std::cout << ns1::ns2::x << std::endl;  // 打印ns2的x值
    std::cout << ns1::ns2::ns3::x << std::endl;  // 打印ns3的x值
    return 0;
}

这里只是三层嵌套，写起来还行，那如果是100层，1000层的嵌套，该怎么办呢？
用namespace定义一个新的名字空间来代表这个长的嵌套：

#include 

namespace ns1
{
    int x = 100;
    namespace ns2
    {
        int x = 200;
        namespace ns3
        {
            int x = 300;
        }
    }
}

int main(void)
{
    std::cout << ns1::x << std::endl;           // 打印ns1的x值
    std::cout << ns1::ns2::x << std::endl;      // 打印ns2的x值
    std::cout << ns1::ns2::ns3::x << std::endl; // 打印ns3的x值
    namespace ns_three = ns1::ns2::ns3;    // 定义一个名字空间来代表这个嵌套
    std::cout << ns_three::x << std::endl; // 打印ns3的x值方便很多

    return 0;
}