C++入门基础知识介绍----命名空间/输入与输出/缺省参数/函数重载

1.命名空间

1.1 namespace 的介绍

        在C/C++中，变量、函数和类都是大量存在的，而这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

例如在C语言项目中，类似下面程序这样的命名冲突是普遍存在的问题，而C++所引入的namespace就是为了更好的解决这样的问题：

#include <stdio.h>
#include <stdlib.h>

int rand = 10;
int main()
{
    // 编译报错：error C2365: “rand”: 重定义；
    // 因为 rand 以前的定义是“函数”
    printf("%d\n", rand);
    return 0;
}

1.2  namespace 的定义

1• 定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
2• namespace 本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量。
3• C++中域包含：函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所以有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
4• namespace 只能定义在全局，当然还可以嵌套定义。
5• 项目工程中多个文件中若定义同名 namespace ，会被认为是同⼀个 namespace，不会发生冲突。
6• C++标准库都放在⼀个叫std(standard)的命名空间中。
 

下面是命名空间的使用举例：
 

#include <stdio.h>
#include <stdlib.h>

// 1. 正常的命名空间定义
// snake是命名空间的名字，⼀般开发中是⽤项⽬名字做命名空间名。

namespace snake
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int left, int right)
    {
        return left + right;
    }
    struct Node
    {
        struct Node* next;
        int val;
    };
}

int main()
{
    // 这⾥默认是访问的是全局的rand函数指针
    printf("%p\n", rand);

    // 访问 namespace 所命名的域中成员需要使用“::”
    // 这⾥访问的是指定 snake 命名空间中的rand
    printf("%d\n", namespace::rand);

    // 访问域中的函数也是如此
    printf("%d\n", namespace::Add(1,2));

    return 0;
}

如果不同的命名空间中有定义相同名称的 变量/函数/类型，通过对应的 命名空间的名字+“::” 即可访问相应命名空间中的变量/函数/类型。

#include <stdio.h>
#include <stdlib.h>


namespace P
{
   int a = 100;
}


namespace Q
{
   int a = 1;
}

int main()
{
    // 访问命名空间 P 中的 a;
    printf("%d/n",P::a);

    // 访问命名空间 Q 中的 a;
    printf("%d/n",Q::a);

    return 0;
}

1.3 命名空间使用

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以我们要使用命名空间中定义的变量/函数/类型，有三种方式：

• 使用 “::”指定命名空间中的成员访问，项目中推荐这种方式。
• 使用 using 将命名空间中某个成员展开，项目中经常访问的且与其他域不存在命名冲突的成员推荐这种⽅式。
• 展开命名空间中全部成员，项⽬不推荐，冲突⻛险很⼤，⽇常⼩练习程序为了⽅便推荐使⽤。

#include<stdio.h>
namespace N
{
    int a = 0;
    int b = 1;
}

int main()
{
    // 编译报错：error C2065: “a”: 未声明的标识符
    printf("%d\n", a);
    return 0;
}
--------------------------------------------------------------
// 指定命名空间访问
int main()
{
    printf("%d\n", N::a);
    return 0;
}

--------------------------------------------------------------

// using将命名空间中某个成员展开
// 此后再访问该成员时就不需要再使用 “::” 来访问
using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0;
}
--------------------------------------------------------------

// 展开命名空间中全部成员
using namespce N;
int main()
{
    printf("%d\n", a);
    printf("%d\n", b);
    return 0;
}

2. C++输入&输出

• <iostream>是Input Output Stream 的缩写，是标准的输⼊、输出流库，定义了标准的输入、输
出对象。
• std::cin 是 istream 类的对象，它主要⾯向窄字符（narrow characters (of type char)）的标准输
⼊流。
• std::cout 是 ostream 类的对象，它主要⾯向窄字符的标准输出流。
• std::endl 是⼀个函数，流插⼊输出时，相当于插⼊⼀个换行字符加刷新缓冲区。
• <<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
• 使⽤C++输⼊输出更方便，不需要像 printf/scanf 输⼊输出时那样，需要手动指定格式，C++的输入/输出可以自动识别变量类型(本质是通过函数重载实现的），其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
• cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。
• ⼀般日常练习中我们可以使用 using namespace std 将 std 命名空间中的内容展开，方便我们直接使用cout/cin/endl，实际项目开发中不建议using namespace std。

#include <iostream>
using namespace std;

int main()
{
    int a = 0;
    double b = 0.1;
    char c = 'x';

    cout << a << " " << b << " " << c << endl;
    std::cout << a << " " << b << " " << c << std::endl;
    
    // iostream 中包含了 scanf 与 printf 
    scanf("%d%lf", &a, &b);
    printf("%d %lf\n", a, b);

    // 可以⾃动识别变量的类型
    cin >> a;
    cin >> b >> c;
    cout << a << endl;
    cout << b << " " << c << endl;
    return 0;
}

3. 缺省参数

• 缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调⽤该函数时，如果没有指定实参，则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（缺省参数也叫默认参数）

例如：

#include <iostream>

using namespace std;

void Func(int a = 0)
{
    cout << a << endl;
}

int main()
{
    Func(); // 没有传参时，使⽤参数的默认值，打印结果a为0
    Func(10); // 传参时，使⽤指定的实参，打印结果a为10
    return 0;
}

• 全缺省就是全部形参都有缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

例如：
 

#include <iostream>
using namespace std;

// 全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl << endl;
}

// 半缺省
void Func2(int a, int b = 10, int c = 20)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl << endl;
}

int main()
{
    Func1();
    Func1(1); // 1传给形参a
    Func1(1,2); // 1、2分别传给形参a，b
    Func1(1,2,3);// 1、2、3分别传给a，b，c
    Func2(100);// 100 传给a
    Func2(100, 200);// 下面同理
    Func2(100, 200, 300);
    return 0;
}

• 调用带缺省参数的函数，C++规定必须从左到右依次给实参，不能跳跃给实参。

例如：

#include <iostream>
using namespace std;

// 半缺省
void Func2(int a, int b = 10, int c = 20)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl << endl;
}

int main()
{
    Func2(1,,3);  // 编译器会报错

    return 0;
}

• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省
值。 

例如：

// Stack.h
#include <iostream>
#include <assert.h>

using namespace std;
typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;

void STInit(ST* ps, int n = 4);


// Stack.cpp
#include"Stack.h"
// 缺省参数不能声明和定义同时给
void STInit(ST* ps, int n)
{
    assert(ps && n > 0);
    ps->a = (STDataType*)malloc(n * sizeof(STDataType));
    ps->top = 0;
    ps->capacity = n;
}


// test.cpp
#include"Stack.h"
int main()
{
    ST s1;
    STInit(&s1);

    // 如果确定知道要插⼊1000个数据，初始化时⼀把开好，避免扩容
    ST s2;
    STInit(&s2, 1000);
    return 0;
}

4. 函数重载

C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。根据使用者所传入的参数个数以及参数类型来调用对应的函数，这样C++函数调用就表现出了多态行为，使用更灵活。而C语言不支持同⼀作用域中出现同名函数。

例如下面这些函数都构成重载：

#include<iostream>
using namespace std;
// 1、参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}

double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}

// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}

void f(int a)
{
    cout << "f(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}

void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

但下面这两个函数不能够成重载：

// 返回值不同不能作为重载条件，调⽤时也⽆法区分到底调用的是哪一个函数
void fxx()
{}

int fxx()
{
    return 0;
}

int main()
{
    fxx();
    return 0;
}

下面这两个函数虽然满足构成重载函数的条件，但调用时却无法区分所调用的是哪一个函数：

// 下⾯两个函数参数个数不同，构成重载
// 但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁
void f1 ()
{
    cout << "f()" << endl;
}

void f1 ( int a = 10)
{
    cout << "f(int a)" << endl;
}

int main()
{
    f1();
    return 0;
}