C++基础：（一）C++入门知识介绍（上）

// test.cpp
#include<stdio.h>

int main()
{
    printf("hello world\n");
    return 0;
}

// test.cpp
// 这⾥的std cout等我们都看不懂，没关系，下⾯我们会依次讲解
#include<iostream>
using namespace std;

int main()
{
    cout << "hello world\n" << endl;
    return 0;
}

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

int rand = 10;

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

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

// 1. 正常的命名空间定义

// bit是命名空间的名字，⼀般开发中是⽤项⽬名字做命名空间名。
// 我在这里⽤的是bit，⼤家可以考虑⽤⾃⼰名字缩写，如张三：
namespace bit
{
    // 命名空间中可以定义变量/函数/类型
    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);
    // 这⾥指定bit命名空间中的rand
    printf("%d\n", bit::rand);

    return 0;
}


//2. 命名空间可以嵌套
namespace bit
{
    namespace op
    {
        int rand = 1;

        int Add(int left, int right)
        {
            return left + right;
        }
    }    

    namespace chen
    {
        int rand = 2;
        int Add(int left, int right)
        {
            return (left + right)*10;
        }
    }
}

int main()
{
    printf("%d\n", bit::pg::rand);
    printf("%d\n", bit::hg::rand);

    printf("%d\n", bit::pg::Add(1, 2));
    printf("%d\n", bit::hg::Add(1, 2));

    return 0;
}


// 多⽂件中可以定义同名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++;
    } 

    //...
}

// Queue.h
#pragma once
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

namespace bit
{
    typedef int QDataType;
    typedef struct QueueNode
    {
        int val;
        struct QueueNode* next;
    }QNode;

    typedef struct Queue
    {
        QNode* phead;
        QNode* ptail;
        int size;
    }Queue;

    void QueueInit(Queue* pq);
    void QueueDestroy(Queue* pq);

    // ⼊队列
    void QueuePush(Queue* pq, QDataType x);
    // 出队列
    void QueuePop(Queue* pq);

    QDataType QueueFront(Queue* pq);
    QDataType QueueBack(Queue* pq);
    bool QueueEmpty(Queue* pq);
    int QueueSize(Queue* pq);
}

// Queue.cpp
#include"Queue.h"
namespace bit
{
    void QueueInit(Queue* pq)
    {
        assert(pq);

        pq->phead = NULL;
        pq->ptail = NULL;
        pq->size = 0;
    } 

    // ...
}

/
/ test.cpp
#include"Queue.h"
#include"Stack.h"

// 全局定义了⼀份单独的Stack
typedef struct Stack
{
    int a[10];
    int top;
}ST;

void STInit(ST* ps){}
void STPush(ST* ps, int x){}

int main()
{
    // 调⽤全局的
    ST st1;
    STInit(&st1);
    STPush(&st1, 1);
    STPush(&st1, 2);
    printf("%d\n", sizeof(st1));
    
    // 调⽤bit namespace的
    bit::ST st2;
    printf("%d\n", sizeof(st2));
    bit::STInit(&st2);
    bit::STPush(&st2, 1);
    bit::STPush(&st2, 2);

    return 0;
}

#include<stdio.h>

namespace bit
{
    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;
}