C++朝花夕拾-using关键字

2025-09-22

字数统计: 1.1k字 | 阅读时长≈ 5分

📘 C++ 中 `using` 关键字的用法详解

在 C++ 中，using 关键字功能强大且用途多样，从 C++11 开始更是得到了显著增强。它主要用于简化代码、提高可读性、解决继承中的函数隐藏问题等。以下是 using 在 C++ 中的主要用法详解：

1️⃣ 引入命名空间成员（Namespace Members）

1.1 引入单个成员

#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::vector;

int main() {
    vector<int> v = {1, 2, 3};
    cout << v[0] << endl; // 不用写 std::
    return 0;
}

✅ 推荐：比 using namespace std; 更安全，避免命名污染。

1.2 引入整个命名空间（谨慎使用）

using namespace std;

int main() {
    cout << "Hello" << endl;
    vector<int> v;
    // ...
}

⚠️ 警告：不要在头文件或大型项目中使用，容易引起命名冲突！

2️⃣ 定义类型别名（Type Alias）— 替代 `typedef`

C++11 起，using 可用于定义类型别名，语法更直观，功能更强。

2.1 基本类型别名

1
2
3

using IntPtr = int*;
using String = std::string;
using Callback = void(*)(int);

等价于：

1
2
3

typedef int* IntPtr;
typedef std::string String;
typedef void(*Callback)(int);

✅ using 语法更符合“赋值”语义：别名 = 原类型

2.2 模板别名（`typedef` 无法做到！）

template<typename T>
using Vec = std::vector<T>;

Vec<int> v1;        // std::vector<int>
Vec<std::string> v2; // std::vector<std::string>

template<typename T>
using MapString = std::map<std::string, T>;

MapString<int> m; // std::map<std::string, int>

🌟 这是 using 最强大的优势之一 —— 支持模板别名！

3️⃣ 在派生类中引入基类成员（解决函数隐藏）

当派生类定义了与基类同名的函数时，基类所有重载版本都会被隐藏。使用 using 可显式引入。

class Base {
public:
    void func(int x) { cout << "Base::func(int)" << endl; }
    void func(double x) { cout << "Base::func(double)" << endl; }
};

class Derived : public Base {
public:
    using Base::func; // 引入所有重载版本 ✅

    void func(char x) { cout << "Derived::func(char)" << endl; }
};

int main() {
    Derived d;
    d.func(10);    // Base::func(int)
    d.func(3.14);  // Base::func(double)
    d.func('a');   // Derived::func(char)
}

❌ 如果没有 using Base::func;，则 d.func(10) 会报错 —— 因为基类函数被隐藏了！

4️⃣ 改变继承成员的访问权限（C++11）

在派生类中，可以用 using 提升或改变从基类继承的成员的访问级别。

class Base {
protected:
    void protectedFunc() { cout << "Protected" << endl; }
public:
    void publicFunc() { cout << "Public" << endl; }
};

class Derived : private Base { // 私有继承
public:
    using Base::publicFunc;     // 保持 public
    using Base::protectedFunc;  // 提升为 public ✅
};

int main() {
    Derived d;
    d.publicFunc();     // ✅
    d.protectedFunc();  // ✅ 现在可以访问了！
}

📌 注意：不能用 using 降低访问权限（比如 public → private），只能提升或保持。

5️⃣ 在模板中引入依赖基类成员（解决编译错误）

在模板派生类中访问基类成员时，有时编译器无法识别，需用 using 或 this-> 显式声明。

template<typename T>
class Base {
protected:
    T value;
};

template<typename T>
class Derived : public Base<T> {
public:
    using Base<T>::value; // ✅ 显式引入依赖基类成员

    void print() {
        std::cout << value << std::endl; // 现在可以访问
    }
};

💡 原因：在模板中，基类是依赖名称（dependent name），编译器默认不查找基类作用域。

📋 总结：`using` 的五大用途

用途	示例	说明
1️⃣ 引入命名空间成员	`using std::cout;`	避免写 `std::`，更安全
2️⃣ 定义类型别名	`using IntVec = std::vector<int>;`	替代 `typedef`，支持模板
3️⃣ 引入基类函数	`using Base::func;`	解决派生类函数隐藏问题
4️⃣ 改变访问权限	`using Base::func;`（在 public 下）	提升继承成员访问级别
5️⃣ 模板中引入基类成员	`using Base<T>::member;`	解决依赖名称查找问题

💡 最佳实践建议

✅ 优先使用 using 定义类型别名（特别是模板别名）
✅ 在类中使用 using 解决函数重载隐藏问题
✅ 在 .cpp 文件中局部使用 using namespace xxx;，避免在头文件中使用
✅ 在模板派生类中，对基类成员使用 using 或 this-> 避免编译错误
❌ 不要用 using 降低访问权限（语法不允许）

🧠 小测验

下面代码能否编译通过？

class A {
public:
    void foo(int);
};

class B : public A {
public:
    void foo(double);
};

int main() {
    B b;
    b.foo(5); // ❓ 会调用哪个？
}

❌ 编译错误！A::foo(int) 被 B::foo(double) 隐藏了。
✅ 解决方案：在 B 中添加 using A::foo;

本文作者： 迪丽惹Bug
本文链接： https://lyroom.github.io/2025/09/22/C-朝花夕拾-using关键字/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！

📘 C++ 中 using 关键字的用法详解