c++_01_名字空间_复合类型_缺省参数_哑元函数

0  前言

        C++和C一样，都属于编译型语言

        C++和C一样，都属于强类型语言

        C++对C完全兼容，并提供更多面向对象的特性：语言风格更加简洁，类型检查更加严格

1  名字空间 namespace

        WHY？划分更精细的逻辑单元(逻辑空间)，有效避免名字的冲突。

        WHAT？名字空间定义：namespace 名字空间名 {...} 

        名字空间合并 ，方便多人协作

        声明定义分开 ，声明在一个文件，定义在一个文件

// nameconf.cpp 名字空间：可以划分更多的逻辑单元（作用域），可以有效避免名字的冲突问题
#include 
namespace ICBC {
    int g_money = 0;
    void save( int money ) {
        g_money += money;
    }
}
namespace CCB {
    int g_money = 0;
    void save( int money ) { // 连 声明 带 定义
        g_money += money;
    }
    void pay( int money );// 声明
}

void CCB::pay( int money ) { // 定义
    g_money -= money;
}

namespace ICBC { // 编译器将合并为一个名字空间
    void pay( int money ) {
        g_money -= money;
    }
}
int main( void ) {
    ICBC::save( 10000 );
    ICBC::pay( 3000 );
    std::cout << "工行卡余额:" << ICBC::g_money << std::endl;

    CCB::save( 8000 );
    CCB::pay( 3000 );
    std::cout << "建行卡余额:" << CCB::g_money << std::endl;
    return 0;
}

         HOW? 怎样使用名字空间的成员？

        1）作用域限定符 :: 

        2）名字空间指令（可见）

        3）名字空间声明（相当于定义，但生命周期为进程级）

// diruse.cpp 名字空间指令
#include 
using namespace std;
namespace ns {
    int g_value = 0;
}

// int g_value = 0;
// using namespace ns; // 从这行代码开始ns中的内容在当前作用域 可见
int main( void ) {
//  int g_value = 0;
    using namespace ns; // 从这行代码开始ns中的内容在当前作用域 可见
    g_value = 100; 
    /*std::*/cout << "ns::g_value=" << ns::g_value << /*std::*/endl;
    return 0;
}

// impname.cpp 名字空间声明
#include 
using namespace std;

namespace ns {
    int g_value = 0;
}

//int g_value = 0;
//using ns::g_value; // 从这行代码开始ns中的g_value引入当前作用域(相当于定义)

int main( void ) {
//  int g_value = 0;
    using ns::g_value; // 从这行代码开始ns中的g_value引入当前作用域(相当于定义)
    g_value = 100; 

    cout << "ns::g_value=" << ns::g_value << endl;
    return 0;
}

        名字空间嵌套

                -内层标识符与外层标识符为隐藏关系（即内外层标识符名字可相同）

                -嵌套的名字空间需要逐层分解（用别名方便）

        名字空间别名

                -可通过名字空间别名，来简化书写：

                namespace  ns_four = ns1::ns2::ns3::ns4;

// netstalias.cpp 名字空间的嵌套
#include 
using namespace std;

namespace ns1 {
    int g_value = 100;
    namespace ns2 {
        int g_value = 200;
        namespace ns3 {
            int g_value = 300;
            namespace ns4 {
                int g_value = 400;
            }
        }
    }
}

int main( void ) {
    namespace ns_four = ns1::ns2::ns3::ns4; // 名字空间别名
    cout << ns_four::g_value << endl; // 可以简化程序的书写
    return 0;
}

2  C++复合类型

2.1  C++的结构

        定义结构型的变量时，可以省略struct关键字

        在结构体内部可以定义成员函数 

        在成员函数的内部可以直接访问本结构体的成员，无需通过"."或"->"

2.2  C++的联合

        定义联合型的变量时，可以省略union关键字

        支持匿名联合

2.3  C++的枚举

        定义枚举型的变量时，可以省略enum关键字

        独立的类型，和整型数据之间不能隐式转换（输red，不能输0。虽然就是0，但类型不同）

// type.c  C++的复合类型,可以省略关键字

#include 

void TestStruct( ) {
    struct Student {
        int m_age;
        char m_name[256];
    };

    /*struct*/ Student s;
}

void TestUnion( ) {
    union A {
        int i;
        char c[4];
    };
    /*union*/ A a;
}

void TestEnum( ) {
    enum Color { red, green, blue };

    /*enum*/ Color c;
}
int main( void ) {
    
    return 0;
}

// type2.cpp C++的复合类型

#include 
#include 
using namespace std;

void TestStruct( ) {
    struct Student {
        int m_age; // 成员变量
        char m_name[256]; // 成员变量
        void getinfo( ) { // 成员函数
            cout << m_name << ' ' << m_age << endl; 
            //成员函数内部可以直接访问本结构的成员
        }
    };

    /*struct*/ Student s;
    s.m_age = 22;
    strcpy( s.m_name, "张飞" );
    cout << "姓名: " << s.m_name << ", 年龄: " << s.m_age << endl;
    s.getinfo();
}

void TestUnion( ) {
    union { // 匿名联合体,主要体现联合体内部成员的内存排布方式
        int i;
        char c[4];
    };
    i = 0x12345678; // 小端：低数位占低地址
    cout << hex << (int)c[0]<< ' ' << (int)c[1] << ' ' << (int)c[2] 
         << ' ' << (int)c[3] << endl;
} 

void TestEnum( ) {
    enum Color { red, green, blue };

    /*enum*/ Color c = red; // 0-error
    cout << c << endl;
}

void TestBool( ) {
    bool a = 'A'; // ""; // "fds"; // 0.000000001; // 123; // true;
    bool b = '\0'; // NULL;    // 0.000000000; // 0;   // false;
    cout << "a=" << a << ", b=" << b << endl;
}
int main( void ) {
    TestBool( );
//  TestEnum( );
//  TestUnion( );
//  TestStruct( );

    return 0;
}
//表示布尔量的数据类型：    bool
//布尔类型的字面值常量：    true false  分别表示真假
//布尔类型的本质：          1    0      单字节整数
//任何基本类型的数据都可被隐式转换为布尔类型：    非0为真，0为假

2.4  引用、指针、数组、字符串、string类...

3  缺省参数

        可以为函数的形参指定缺省(默认)值，这种参数称为缺省参数。

        缺省值不是默认值！

        当调用该函数时若未指定实参，则使用形参的缺省值。 

        如果函数的某个形参具有缺省值，那么该形参后面的所有形参都必须有缺省值。

        尽量避免因为使用缺省参数而导致重载匹配歧义：

                void foo( int a,  float b = 2.3, double c = 4.5 ) {};

                void foo( int a ) {};  // 虽构成重载，但编译时会报匹配歧义ambiguous错

        函数形参的缺省值只能在函数声明中指定。

// defparam.cpp 缺省参数:带默认值的形参(默认值不是初始值)

#include 
using namespace std;

void foo( int a, double b, float c, short d, char e='A' ) {
    cout << "e=" << e << endl;
}

int main( void ) {
    foo( 3, 3.14, 3.1, 2 );
    foo( 3, 3.14, 3.1, 2, 'B' );
    return 0;
}

4  哑元函数

        只指定形参类型而不指定形参名称的函数。

        用途：保证函数的向前兼容。（老用户继续带参，新用户随意带参）

// forover.cpp 哑元函数
#include 
using namespace std;
void foo( int ) {
    
    // 高精尖的人工智能算法,不需要用户传递数据，也可以得到正确的结果
    // 函数内部 不能获取 用户传递的实参数据
}

int main( void ) {
    foo( 10 );
    return 0;
}