利用template和using构造别名

最新推荐文章于 2025-09-26 16:50:53 发布
原创 最新推荐文章于 2025-09-26 16:50:53 发布 · 4.4k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #template #别名 #函数指针

本文介绍了C++11中模板别名的使用，如何替代传统方法提高代码可读性，特别是对于函数指针的定义。通过示例展示了如何创建类型别名，并解释了为何不能在函数内部定义包含模板的别名，以及编译器对此的限制。

今天碰巧看到知乎一个问题：如何评价网易校招C++的笔试题？。发现自以为掌握了C++大部分实用基础语法的自己，还不知道template可以这么使用。

通过查阅资料C++11 理解 (十五) 之 模板的别名， 模板的别名（1），发现自从C++11后，template配合using可以完全替代，甚至更好地完成typedef的工作。

例如我可以这么定义某个类型的指针

template<typename T> using ptr=T*;

就可以很顺利地完成这个工作。并且还不会像typedef一样局限于某个特定的类型。当使用时如下：

    int a=1;
    ptr<int> pi=&a;

如果说这在一

最低0.47元/天 解锁文章
using 继承构造函数+类型别名与别名模板声明
一只懒虫的博客
06-06 1033
文章目录1.using的基本用法2.c++11新特性之继承构造函数3.c++11新特性之类型别名与别名模板声明 1.using的基本用法 命名空间声明，或将命名空间名字导入到当前命名空间或作用域。 void fun(){ using std::string;//导入名字到函数作用域 string s("sss"); } #include <iostream> us...
c++中别名的定义 using、#define、typedef、typename、namespace的使用
舒海文的博客
01-16 2557
typedef typename #define namespace using区别 1.关键字typedef定义别名 2.typename 3.文本替换宏define 4.using 5.namespace 使用在命名空间上 1.关键字typedef定义别名 //例1：定义变量别名 typedef unsigned int size_t; //size_t是unsigned in...
C++中的template ＜typename T＞用法详解
weixin_44884561的博客
02-15 8112
C++中的template 用法详解
C++中using关键字全面讲解
最新发布
SKY_PPCH的博客
09-26 1006
摘要：C++中的using关键字主要有三种用途：1)类型别名（C++11引入，替代typedef，语法更清晰且支持模板别名）；2)命名空间使用（可全局或局部引入，推荐选择性引入）；3)继承构造函数（C++11引入）。using创建的类型别名在编译期等价于原始类型，无运行时开销，特别适合模板编程和复杂类型简化。最佳实践包括：头文件中避免全局using，优先使用模板别名，函数内部局部引入命名空间。using显著提升了C++代码的可读性和现代性。
C++模板---泛型编程
lwd906485829的博客
03-16 3081
第2章 函数模板 函数模板提供了一种函数行为，该函数行为可以用多种不同的类型进行调用；也就是说，函数模板代表一个函数族、它表示看起来和普通的函数很相似，唯一的区别就是有些函数元素是未确定的：这些元素将在使用时被参数化 定义模板： template <typename T> inline T const& max(T const&a, T const& b) { return a < b ? b:a; } 实参推导： 当我们为某些实参调用一个诸如max()
using和template同时使用的方法
jenie的专栏
06-07 863
如果有这样的定义 template <class T> using XXX = const T; 则 xxx<int> x 等于 const int x #include <iostream> template <typename TYPE> using IN = const TYPE&; int add(IN<int> a, IN<int> b) { return a+b; } int m..
template, using用法
hyl999的专栏
07-28 1027
//方法一 template <typename T> struct map_s { typedef std::map <std::string, T> map; } map_s<int>::map map1; map1.insert({"key", 1}); //方法二 template <typename T> using map_s = std::map<std::string, T>; map_s<int> ma.
77、模板别名：简化复杂模板类型的利器
nnn11的博客
06-06 636
本文深入探讨了C++中模板别名（Template Aliases）的定义、语法、优势及应用场景，通过多个实例展示了如何使用模板别名简化复杂类型、提高代码可读性和维护性。同时，文章还介绍了模板别名与模板特化、模板参数包、类型推导等高级特性的结合使用方法，并总结了其最佳实践和局限性。
C/C++ 知识点：using 关键字
个人技术博客
08-12 1089
using关键字在C++中是一个非常重要的特性，它提供了多种用途，从命名空间的简化到类型别名的定义，再到模板编程中的灵活应用。掌握using的用法，可以使C++代码更加简洁、清晰和易于维护。然而，也需要注意using可能引起的命名冲突问题，尤其是在大型项目或头文件中使用时。
c++11 template using,模板别名
gonaYet的博客
12-05 4247
c++11特性 template using,模板别名 作用： 当已经存在一个模板，其参数列表比较长，但是有一些模板参数默认基本是可以确定的， 因此可以使用这个模板别名来少些这些参数 例子: template class A {  public: A(T num) : num_(num) {}, void execute() { if (flag) do a....;
Using template in practice(实际运用)
痞子
10-11 491
c++ template
C++11特性：使用using和typedef给模板定义别名
qq_73185160的博客
12-17 1239
被重定义的类型并不是一个新的类型，仅仅只是原有的类型取了一个新的名字。在使用的时候，关键字using作为别名声明的开始，其后紧跟别名和等号，其作用是把等号左侧的名字规定成等号右侧类型的别名。类型别名和类型的名字等价，只要是类型的名字能出现的地方，就能使用类型别名。使用typedef定义的别名和使用using定义的别名在语义上是等效的。上面的例子中通过使用using给模板指定别名，就可以基于别名非常方便的给value指定相应的类型，这样使编写的程序变得更加灵活，看起来也更加简洁一些。
C++11——模板别名
weixin_67452474的博客
10-12 844
模板别名
[C++11]通过using定义基础类型和函数指针别名
u013049912的博客
09-15 317
[C++11]通过using定义基础类型和函数指针别名_m0_51955470的博客-优快云博客_c++11 using 函数指针
32.C++-11版本推荐使用using定义别名（替代typedef）
抵抗时间扭曲，坚持做一件有意义的事
12-07 522
大家都知道，在 C++中可以通过 typedef 重定义一个类型： typedef unsigned int uint_t; 被重定义的类型并不是一个新的类型，仅仅只是原有的类型取了一个新的名字。 但是不能用于模版别名,所以C++11版本推荐,通过using来代替typedef 示例如下所示: template<typename T> class Test { public...
C++11：使用using定义别名
crossoverpptx的博客
07-04 1642
本文介绍 C++11 中使用 using 定义别名的用法。
15.5 using定义模板别名与显式指定模板参数
zzyzxb的博客
05-23 291
using定义模板别名与显式指定模板参数
Th4.5：using定义模板别名之详述
weixin_44980842的博客
11-29 1271
本小节回顾的知识点是using定义模板别名。 using（来）定义模板的别名： 在介绍今天要总结的using关键字的“新”功能前，先来介绍一下typedef关键字的用法： typedef : 一般是用来定义类型别名（也即给类型起一个别名） 格式： typedef Type TypeName;//给类型Type起一个别名TypeName typedef retName (*pointerName)(FuncParams);//定义一种指向retNam...
using用法
07-08
<think>我们被要求详细解释C++中using关键字的用法。根据C++标准，using关键字主要有三种用途： 1. 引入命名空间（using-directive和using-declaration） 2. 在类继承中引入基类成员（using-declaration） 3. 类型别名（type alias），在C++11中引入，用于替代typedef 此外，C++20中还引入了using enum，用于在作用域中引入枚举成员。 下面我们逐一详细解释。 ### 1. 引入命名空间 #### (1) using指令（using-directive） 使用`using namespace`后跟命名空间名称，可以将整个命名空间引入当前作用域。 ```cpp #include <iostream> using namespace std; // 引入整个std命名空间 int main() { cout << "Hello, World!" << endl; // 可以直接使用cout和endl，而不需要std:: return 0; } ``` **注意**：在头文件中避免使用using指令，以免造成命名污染。 #### (2) using声明（using-declaration） 使用`using`后跟特定名称，可以将命名空间中的某个名称引入当前作用域。 ```cpp #include <iostream> using std::cout; // 只引入std中的cout using std::endl; // 只引入std中的endl int main() { cout << "Hello, World!" << endl; return 0; } ``` 这种方式更安全，因为它只引入指定的名称，减少了命名冲突的可能性。 ### 2. 在类继承中引入基类成员 当派生类私有继承基类时，基类的公有和保护成员在派生类中变为私有。如果希望这些成员在派生类中保持原有的访问权限，可以使用using声明。 此外，当基类的成员函数（尤其是重载函数）被派生类覆盖（override）时，如果希望保留基类的重载版本，也可以使用using声明。 示例： ```cpp class Base { public: void func() { cout << "Base::func()" << endl; } void func(int) { cout << "Base::func(int)" << endl; } // 重载函数 protected: int value; }; class Derived : private Base { // 私有继承 public: using Base::func; // 引入Base中的所有func重载函数，使其在Derived中保持public using Base::value; // 引入Base中的value，使其在Derived中保持protected }; int main() { Derived d; d.func(); // 正确，Base::func()在Derived中是public d.func(10); // 正确，Base::func(int)在Derived中是public // d.value = 10; // 错误，value在Derived中是protected，不能在类外访问 return 0; } ``` ### 3. 类型别名（C++11起） 在C++11中，using可以用于定义类型别名，功能类似typedef，但更灵活，特别是可以用于模板别名。 #### (1) 非模板类型别名 ```cpp using IntPointer = int*; // 等价于typedef int* IntPointer; IntPointer p; // 函数指针别名 using Func = void(*)(int, int); // 等价于typedef void(*Func)(int, int); ``` #### (2) 模板别名（typedef不能直接实现） 这是using比typedef更强大的地方，可以用于定义模板别名。 ```cpp template <typename T> using Vec = std::vector<T>; // 模板别名 // 使用 Vec<int> v; // 等价于std::vector<int> v; ``` 另一个例子，定义带有自定义分配器的vector： ```cpp template <typename T> using MyAllocVec = std::vector<T, MyAllocator<T>>; MyAllocVec<int> v; // 使用自定义分配器的vector ``` ### 4. using enum（C++20） C++20允许使用`using enum`将枚举类型的所有枚举成员引入当前作用域，避免重复写枚举类型名。 ```cpp enum class Color { red, green, blue }; void print(Color c) { switch (c) { using enum Color; // 引入Color的所有枚举成员 case red: cout << "red"; break; case green: cout << "green"; break; case blue: cout << "blue"; break; } } ``` ### 总结 | **用途** | **语法示例** | **说明** | |------------------------------|-------------------------------------------|--------------------------------------| | 引入整个命名空间 | `using namespace std;` | 全局或局部作用域 | | 引入命名空间中特定名称 | `using std::cout;` | 更安全 | | 在派生类中引入基类成员 | `using Base::func;` | 调整基类成员在派生类中的访问权限 | | 类型别名（非模板） | `using IntPointer = int*;` | 替代typedef | | 模板别名 | `template<typename T> using Vec=vector<T>;` | 支持模板，typedef无法实现 | | 引入枚举成员（C++20） | `using enum Color;` | 简化枚举成员的使用 | ### 注意事项 - 在头文件中，尽量避免使用`using namespace`，以防止命名空间污染。 - 使用类型别名时，注意别名的作用域。 - 在类中使用using引入基类成员时，注意访问控制（public、protected、private）的位置会影响引入后的访问权限。 --- §§ 相关问题 §§ 1. C++中的typedef和using在定义类型别名时有何区别？ 2. 为什么在头文件中要避免使用`using namespace`？ 3. 在类继承中，使用using声明引入基类成员时，如何控制访问权限？ 4. C++20的using enum还有哪些使用场景？ 5. 模板别名能否用于部分特化？如何实现？</think>### C++ `using` 关键字用法详解 `using` 关键字在 C++ 中有多种用途，主要包括以下四种场景： --- #### 一、命名空间引入（最常见用法） 1. **引入整个命名空间** ```cpp #include <iostream> using namespace std; // 引入std命名空间 int main() { cout << "Hello"; // 无需写std::cout return 0; } ``` **注意**：在头文件中避免使用，防止命名污染[^1]。 2. **引入特定成员** ```cpp using std::cout; // 仅引入cout using std::endl; // 仅引入endl int main() { cout << "Safe" << endl; // 精确控制 return 0; } ``` --- #### 二、类型别名（C++11起） 替代 `typedef`，更直观的语法： ```cpp // 基本类型别名 using StringVector = std::vector<std::string>; // 等价于typedef // 函数指针别名 using Handler = void(*)(int, const std::string&); // 模板别名（typedef无法实现） template<typename T> using Matrix = std::vector<std::vector<T>>; // 模板化别名 // 使用示例 Matrix<double> mat(3, std::vector<double>(3)); Handler callback = [](int, const std::string&){ /*...*/ }; ``` --- #### 三、类成员引入（继承场景） 解决派生类隐藏基类成员问题： ```cpp class Base { public: void func(int x) { /*...*/ } }; class Derived : public Base { public: using Base::func; // 引入基类版本 void func(double x) { /*...*/ } // 新重载 }; int main() { Derived d; d.func(5); // 调用Base::func(int) d.func(5.0); // 调用Derived::func(double) } ``` --- #### 四、构造函数继承（C++11起） ```cpp class Base { public: explicit Base(int) {} }; class Derived : public Base { public: using Base::Base; // 继承所有基类构造函数 // 自动生成：Derived(int) : Base(int) {} }; // 使用 Derived d(42); // 调用继承的构造函数 ``` --- ### 对比表：`using` vs `typedef` | **特性** | `using` | `typedef` | |------------------------|-----------------------------|-------------------------| | 模板别名 | ✅ `template<T> using Vec=vector<T>` | ❌ 不支持 | | 函数指针可读性 | ✅ `using Handler=void(*)(int)` | ⚠️ `typedef void(*Handler)(int)` | | 继承构造函数 | ✅ 支持 | ❌ 不支持 | | 引入命名空间成员 | ✅ 支持 | ❌ 不支持 | | 兼容性 | C++11+ | C++98+ | --- ### 最佳实践建议 1. **命名空间引入** - 源文件：`using namespace std` 可接受 - 头文件：**严格使用** `std::` 前缀或部分引入（如 `using std::string`） 2. **类型别名** - 优先使用 `using`（更清晰的模板别名语法） - 旧代码迁移时逐步替换 `typedef` 3. **类成员引入** ```cpp class CustomVector : public std::vector<int> { public: using std::vector<int>::vector; // 继承构造函数 using std::vector<int>::operator[]; // 引入特定成员 }; ``` > 关键点：`using` 在模板别名和构造函数继承上具有不可替代性[^1][^3]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值