C++ using全解析

#include <iostream>

int main() {
    // 没用 using 之前，必须写 std::
    std::cout << "Hello" << std::endl;
    
    // 用 using 声明后，可以直接写 cout 和 endl
    using std::cout;
    using std::endl;
    
    cout << "Hello" << endl;  // 不需要 std::
    
    // 其他没引入的成员，仍然需要 std::
    int a;
    std::cin >> a;  // cin 没引入，还是要写 std::
    
    return 0;
}

#include <iostream>
using namespace std;  // 引入整个 std 命名空间

int main() {
    cout << "Hello" << endl;  // 直接使用
    int a;
    cin >> a;
    return 0;
}

namespace A {
    void func() { cout << "A" << endl; }
}

namespace B {
    void func() { cout << "B" << endl; }
}

using namespace A;
using namespace B;

int main() {
    func();  // ❌ 错误：不知道调用 A::func 还是 B::func
}

A::func();  // 明确调用 A 的 func
B::func();  // 明确调用 B 的 func

using A::func;  // 只引入 A 的 func
func();         // 调用 A::func
B::func();      // B 的 func 还是写全名

{
    using namespace A;
    func();  // 在这个大括号里，func 指 A::func
}
{
    using namespace B;
    func();  // 在这个大括号里，func 指 B::func
}

typedef unsigned int u_int;      // 无符号整型
typedef char* pChar;              // 字符指针
typedef int Array[10];            // 数组
typedef void (*pFun)(int, int);   // 函数指针

using u_int = unsigned int;       // 无符号整型
using pChar = char*;              // 字符指针
using Array = int[10];            // 数组
using pFun = void(*)(int, int);   // 函数指针

using value_type = int;
using pointer = int*;
using const_pointer = const int*;
using reference = int&;
using const_reference = const int&;

template<class T, size_t N>
using Array = T[N];

int main() {
    Array<int, 5> ar;      // int ar[5]
    Array<int, 5> br;      // int br[5]
    
    Array<double, 5> dr;   // double dr[5]
    
    Array<int*, 10> par;   // int* par[10]
    
    return 0;
}

// typedef 做不到！必须为每个类型单独写
typedef int Array_int_5[5];
typedef double Array_double_5[5];
// 无法模板化

// 简化 STL 容器写法
template<class T>
using Vec = std::vector<T>;

int main() {
    Vec<int> v;        // 等价于 std::vector<int>
    Vec<double> d;     // 等价于 std::vector<double>
    Vec<string> s;     // 等价于 std::vector<string>
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

// 1. 类型别名：简化复杂类型
using UInt = unsigned int;
using PFunc = void(*)(int);  // 函数指针类型

// 2. 模板别名：简化嵌套容器
template<class T>
using Vec2D = vector<vector<T>>;  // 二维数组

void printInt(int x) {
    cout << x << endl;
}

int main() {
    // 类型别名使用
    UInt a = 10;           // unsigned int
    PFunc f = printInt;    // 函数指针
    f(a);
    
    // 不用模板别名：写法冗长
    vector<vector<int>> m1 = {{1, 2}, {3, 4}};
    
    // 用模板别名：写法简洁
    Vec2D<int> m2 = {{1, 2}, {3, 4}};  // 等价于 vector<vector<int>>
    
    for (auto& row : m2) {
        for (auto x : row) {
            cout << x << " ";
        }
        cout << endl;
    }
    
    return 0;
}