C＋＋入门基础

1. C++的第一个程序

当然C++有⼀套自己的输入输出，严格说C++版本的hello world应该是这样写的。 

2. 命名空间

2.1 namespace（命名空间）的价值

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。 c语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++引入namespace就是为了更好的解决这样的问题 。

先这样编译，程序是没毛病的。当包一个头文件<stdlib.h>就会报错。这是什么问题呢？

头文件在预处理阶段不会展开，但是会把头文件的内容拷贝到这里来 ，展开头文件就是在预处理阶段，把它的内容拷贝过来。这里面也有一个rand的函数，这个时候就叫做命名冲突。库里面用的rand的名字定义了一个函数，而用rand去定义一个变量，这个时候就会冲突。这个冲突在项目开发里面是非常多的，什么时候会冲突呢？

就是有时候我们定义的变量或者函数会和库里面冲突。在工程项目里面，大的程序不可能是一个人开发的。

刚才会冲突的原因是：在这里定义了一个rand，包含的头文件展开的时候也有一个函数rand，它们都在全局域，所以就冲突了。

修改后的代码： 

现在我加了一个命名空间以后，就形成了一个新的域，<stdlib.h> 展开了以后，rand是依旧存在的，但是rand放到了命名空间域中了，这个时候就不会冲突了。

这里其实是当stdlib.h这个头文件展开时，包含域rand，当定义在namespace中时，就不是一个域了。这时代码就不会报错了。：：域作用限定符。

函数的指定（指定函数的命名空间） 

数组的指定（指定数组的命名空间）

2.2 namespace的定义

• 定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{ }即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。

• namespace本质是定义出⼀个域，这个域跟全局域各自独立，在同一个域不能定义同名变量，不同的域可以定义同名变量，所以下面的rand不在冲突了。

• C++中域有函数局部域，全局域，命名空间域，类域（这几个域都可以做名字隔离，在这几个域中定义同一个变量名，是不会冲突的）；域影响的是编译时语法查找一个变量/函数/ 类型出处(声明或定义)的逻辑，所以有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。命名空间域中的成员生命周期也是全局的。

• namespace只能定义在全局，当然他还可以嵌套定义。

命名空间域中成员的访问： 

• 项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。

// 多文件中可以定义同名namespace，他们会默认合并到⼀起，就像同⼀个namespace⼀样
// Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
namespace bit
{
    typedef int STDataType;
    typedef struct Stack
    {
        STDataType* a;
        int top;
        int capacity;
    }ST;
    void STInit(ST* ps, int n);
    void STDestroy(ST* ps);
    void STPush(ST* ps, STDataType x);
    void STPop(ST* ps);
    STDataType STTop(ST* ps);
    int STSize(ST* ps);
    bool STEmpty(ST* ps);
}
// Stack.cpp
#include"Stack.h"
namespace bit
{
    void STInit(ST* ps, int n)
    {
        assert(ps);
        ps->a = (STDataType*)malloc(n * sizeof(STDataType));
        ps->top = 0;
        ps->capacity = n;
    }
    // 栈顶
    void STPush(ST* ps, STDataType x)
    {
        assert(ps);
        // 满了， 扩容
        if (ps->top == ps->capacity)
        {
            printf("扩容\n");
            int newcapacity = ps->capacity == 0 ? 4 : ps->capacity
                * 2;
            STDataType* tmp = (STDataType*)realloc(ps->a,
                newcapacity * sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            ps->a = tmp;
            ps->capacity = newcapacity;
        }
        ps->a[ps->top] = x;
        ps->top++;
    }
    //...
}

• C++标准库都放在⼀个叫std(standard)的命名空间中。

命名空间的概念：做名字隔离，解决命名冲突的问题。

注：命名空间域（本身就是一个全局域）不能定义在局部中，命名空间的作用就是和全局变量隔离。

2.3 命名空间使用

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

• 指定命名空间访问，项目中推荐这种方式。

• using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。

• 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

展开命名空间相当于是把这个域里面的成员直接暴露到全局去，相当于把它变成了全局变量。 

对于下面一串代码： 

#include<stdio.h>
namespace xsq
{
    int a = 20;
    int b = 1;
}
int main()
{
    // 编译报错：error C2065: “a”: 未声明的标识符
    printf("%d\n", a);
    return 0;
}

编译报错的原因：编译器会去局部变量或者全局变量里去找，不会去命名空间里面找，就出现报错的现象。

解决方案：

//指定命名空间访问
//int main()
//{
//    printf("%d\n", xsq::a);
//    return 0;
//}
//using将命名空间中某个成员展开
//using xsq::b;
//int main()
//{
//    printf("%d\n", xsq::a);
//    printf("%d\n", b);
//    return 0;
//}
//将命名空间展开，其实这种方式还有一个弊端，当全局变量和该变量相同时，就会发生冲突
//using namespace xsq;
//int main()
//{
//    printf("%d\n", b);
//    return 0;
//}

3. C++输入&输出

注：C＋＋如何控制小数点后的位数呢，还有打印的宽度呢？其实也是有的，等到后面我们再介绍，建议还是用printf，而宽度是非常麻烦的。在使用C＋＋的过程中，使用的cout和endl比较多，我们可以使用using展示出来。

用cout和cin想让效率高一些，就要加入下面的一些代码：

// 在 io 需求⽐较⾼的地⽅，如部分大量输⼊的竞赛题中，加上以下 3 ⾏代码

// 可以提⾼ C++IO 效率

ios_base:: sync_with_stdio ( false );

cin. tie ( nullptr );

cout. tie ( nullptr );

// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl;
}
int main()
{
    f();
    f(10);
    return 0;
} 

// 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;
}

int main()
{
    f(10, 'a');
    f('a', 10);
    return 0;
}

 //函数重载用在swap交换函数中

void swap(int* x, int* y)
{
    //....
}
void swap(double* x, double* y)
{
    //....
}
int main()
{
    int a = 1, b = 2;
    double c = 1.1, d = 2.2;
    swap(&a, &b);
    swap(&c,&d);
    return 0;
}

 

如果返回值不同构成重载的话，如何区分？

如果有返回值，可以选择不接收，返回值不同，到底调用的是有返回值的，还是无返回值的。 

// 下⾯两个函数构成重载（参数个数不同，所以构成重载）

//不调用是没问题的，语法上过得去

// f( ) 但是调用时，会报错，存在歧义，编译器不知道调用谁

void f1 ()

{

cout << "f()" << endl;

}

void f1 ( int a = 10 )

{

cout << "f(int a)" << endl;

}

不传参时，编译器会报错，传参时，调用第二个