两个冒号连用python

#include<iostream>
using namespace std;

int atk = 200;
int main()
{
        
    int atk = 100;
    cout<<"局部atk = " << atk << endl; # 100

    // 双冒号 作用域运算符 :: 全局作用域， 冒号前没有任何值，表示全局作用域，
    // std::cout 表示std作用域中的cout函数
    cout<< "全局atk = "<< atk << endl; # 200
    retrun 0;
}

namespace用法：

// 文件game1.h
#include<iostream>
using namespace std;
void goAtk();

// 文件game1.cpp
#include "game1.h"
void goAtk(){
    cout << "LOL 攻击实现"<< endl;
}

// 文件game2.h
#include<iostream>
using namespace std;
void goAtk();

// 文件game2.cpp
#include "game2.h"
using namespace std;
void goAtk(){
    cout << "王者荣耀 攻击实现"<< endl;
}


// 文件main.cpp
#include<iostream>
#include "game1.h"
#include "game2.h"

int main()
{
    goAtk();// 出错，因为该方法产生二义性，系统不知道调用哪个goAtk()方法
    return 0;
}

解决方式如下：

// 文件game1.h
#include<iostream>
using namespace std;
namespace LOL
{
    void goAtk();
}

// 文件game1.cpp
#include "game1.h"
void LOL::goAtk(){
    cout << "LOL 攻击实现"<< endl;
}

// 文件game2.h
#include<iostream>
using namespace std;
namespace KingGlory
{
    void goAtk();
}

// 文件game2.cpp
#include "game2.h"
using namespace std;
void KingGlory::goAtk(){
    cout << "王者荣耀 攻击实现"<< endl;
}


// 文件main.cpp
#include<iostream>
#include "game1.h"
#include "game2.h"

int main()
{
    LOL::goAtk();// 
    return 0;
}

总结

namespace命名空间主要用途： 解决命名冲突的问题

1.命名空间下 可以放函数、变量、结构体、类

namespace A
{
    void func();
    int m_A;
    struct Person
    {
        
    };
    class Animal{};
}

2.命名空间必须定义在全局作用域下

3.命名空间可以嵌套命名空间

namespace A
{
    void func();
    int m_A = 20;
    struct Person
    {
        
    };
    class Animal{};
    namespace B
    {
        int m_A = 10;
    }
}

void test02()
{
    cout<< "作用域B下的m_A为： "<< A::B::m_A <<endl;
}

4.命名空间是开放的，可以随时往原先的命名空间添加内容

namespace A
{
    void func();
    int m_A = 20;
    struct Person
    {
        
    };
    class Animal{};
    namespace B
    {
        int m_A = 10;
    }
}

namespace A // 此命名空间会和上面的命名空间A进行合并
{
    int m_B  = 1000;
}

///
void test03()
{
    cout << "A::下的m_A为" << A::m_A <<" m_B为： " << A::m_B << endl;// 20 1000
}

5. 无名、匿名命名空间, 相当于写了static

namespace
{
    int m_C = 0;
    int m_D = 0;
}

// 相当于写了static int m_C; static int m_D
// 静态变量只能在当前文件内使用

6.命名空间可以起别名

namespace veryLongName
{
    int m_A = 0;
}

void test04()
{
    // 起别名
    namespace veryShortName = veryLongName;
    cout << veryShortName::m_A <<endl; // 0
    cout << veryLongName::m_A <<endl; // 0
}

using的使用

namespace KingGlory
{
    int sunwukongId = 10;
}
void test01()
{
    int sunwukongId = 20;

    cout << sunwukongId << endl; // 20

    // using 声明 注意避免二义性问题
    // 写了using声明后，下面这行代码说明以后看到的sunwukongId是用KingGlory下的
    // 但是， 编译器又有就近原则
    // 二义性
    using KingGlory::sunwukongId;
    cout << sunwukongId << endl;// 出错，出现二义性
}

1.using编译指令

void test02()
{
    int sunwukongId  = 20;
    // using 编译指令
    using namespace KingGlory;
    cout << sunwukongId << endl; // 20, 使用的局部变量
}

namespace LOL
{
    int sunwukongId = 30;
}

void test03()
{
    //using编译指令
    using namespace KingGlory; // 打开王者荣耀房间
    using namespace LOL; // 打开LOL房间
    //如果打开多个房间，也要避免二义性问题
    cout << LOL::sunwukongId << endl;
}

C++对C语言的增强

// C语言
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

// 1.全局变量检测器增强
int a;
int a = 10; // 在c语言中编译通过，因为第一个int a;表示声明，int a = 10;表示定义

// 2.函数检测增强, 参数类型增强, 返回值检测增强-要求必须有返回值, 函数调用参数检测增强
int getRectS(w, h) // c语言通过，c++不通过(参数和返回值)；
{
    
}
//c++中针对上面函数必须如下定义：
int getRectS(int w, int h)
{
    return w*h;
}

void test02()// c语言通过，c++不通过
{
    getRectS(10, 10, 10);// 函数调用参数检测增强
}

// 3.类型转换检测增强
void test03()
{
    char *p = malloc(sizeof(64)); // malloc返回值是void *,万能指针，什么都能指
    // 在c++中出错， 必须像下面这样写
    char *p = (char *)malloc(sizeof(64)); // 必须强制转换成p需要的char *类型
}

// 4. struct增强
struct Person
{
    int m_Age;
    void plusAge(){m_Age++;}; // 1.c语言中struct不可以加函数， c++中struct可以添加函数
}
void test04()
{
    struct Person p1; // 2.c语言中， 使用的时候必须加入struct关键字， c++可以不写
    Person p2;
    p2.m_Age = 10;
    p2.plusAge();
    cout << p2.Age << endl;
}

// 5. bool类型增强
// c语言中没有bool类型
bool flag = True; //只有真或假 真(非0) false 代表假(0)
void test05()
{
    cout << sizeof(flag) << endl; // 1
}

// 6. 三目运算符增强
void test06() // c
{
    int a = 10;
    int b = 20;
    printf("ret = %d \n", a>b? a: b);
    
    a > b ? a : b = 100;// 不通过, c语言返回的是值

    // c语言中想模仿c++写
    *(a > b ? &a : &b) = 100;
}
void test06() // c++
{
    int a = 10;
    int b = 20;
    cout << (a > b? a : b) << endl;
    (a > b ? a : b) = 100; // 通过
    cout << "a = " << a << " b = " << b << endl; // 10， 100
    // b = 100; c++返回的是这个变量
}

// 7.const增强
const int m_A = 10; // 受到保护，不可以修改
void test07() // c情况下
{
    //m_A = 100;
    const int m_B = 20; // 伪常量
    // m_B = 100;// 不可以修改
    int *p = (int *)&m_B; // 可以通过指针指向的形式对局部static常量进行修改
    *p = 200;
    printf("*p = %d, m_B = %d \n", *p, m_B); // 200, 200
    //int arr[m_B]; // 不可以初始化数组
}
void test07() // c++情况下
{
    //m_A = 100;
    const int m_B = 20; // 真正的常量
    // m_B = 100;// 不可以修改
    int *p = (int *)&m_B; // 同样可以通过指针指向局部static变量
    *p = 200;
    printf("*p = %d, m_B = %d \n", *p, m_B); // 200, 20
    //int arr[m_B]; // 不可以初始化数组
}
// c语言中，const修饰的变量，是伪常量， 编译器是会分配内存的
// c++中，const不会分配内存，const int m_B = 20;

对const的解释：