在 Java 中，您可以定义只接受扩展您选择的类的类型的泛型类，例如：
public class ObservableList<T extends List> {
...
}
这是使用“扩展”关键字完成的。
在 C++ 中是否有一些与 this 关键字等效的简单方法？
【问题讨论】：
C++20 概念使用示例
改编自
#include <cassert>
#include <concepts>
struct ClassWithMyFunc {
int myFunc() {
return 1;
}
};
struct ClassWithoutMyFunc {};
// Concept HasMyFunc: type 'T' has `.myFunc` and
// its return is convertible to int.
template<typename T>
concept HasMyFunc= requires(T a) {
{ a.myFunc() } -> std::convertible_to<int>;
};
// Constrained function template
template<HasMyFunc T>
int f(T t) {
return t.myFunc() + 1;
}
int main() {
assert(f(ClassWithMyFunc()) == 2);
// assert(f(ClassWithoutMyFunc()) == 2);
}
编译运行：
g++ -ggdb3 -O0 -std=c++20 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out
如果我们取消注释 // assert(f(ClassWithoutMyFunc()) == 2); 行，它会按预期失败：
In file included from /usr/include/c++/10/cassert:44,
from main.cpp:1:
main.cpp: In function ‘int main()’:
main.cpp:27:34: error: use of function ‘int f(T) [with T = ClassWithoutMyFunc]’ with unsatisfied constraints
27 | assert(f(ClassWithoutMyFunc()) == 2);
| ^
main.cpp:21:5: note: declared here
21 | int f(T t) {
| ^
main.cpp:21:5: note: constraints not satisfied
main.cpp: In instantiation of ‘int f(T) [with T = ClassWithoutMyFunc]’:
main.cpp:27:5: required from here
main.cpp:15:9: required for the satisfaction of ‘HasMyFunc<T>’ [with T = ClassWithoutMyFunc]
main.cpp:15:20: in requirements with ‘T a’ [with T = ClassWithoutMyFunc]
main.cpp:16:15: note: the required expression ‘a.myFunc()’ is invalid
16 | { a.myFunc() } -> std::convertible_to<int>;
| ~~~~~~~~^~
cc1plus: note: set ‘-fconcepts-diagnostics-depth=’ to at least 2 for more detail
需要多个基类
如果您确实需要某些基类之一：
#include <concepts>
#include <type_traits>
struct Base1 {};
struct Base2 {};
struct Derived1 : public Base1 {};
struct Derived2 : public Base2 {};
struct NotDerived {};
template<typename T>
concept HasBase1Or2= std::is_base_of<Base1, T>::value || std::is_base_of<Base2, T>::value;
template<HasBase1Or2 T>
void f(T) {}
int main() {
f(Derived1());
f(Derived2());
// f(NotDerived());
}
如果我们取消注释 // f(NotDerived()); 行，它会按预期失败：
main.cpp: In function ‘int main()’:
main.cpp:22:19: error: use of function ‘void f(T) [with T = NotDerived]’ with unsatisfied constraints
22 | f(NotDerived());
| ^
main.cpp:17:6: note: declared here
17 | void f(T) {}
| ^
main.cpp:17:6: note: constraints not satisfied
main.cpp: In instantiation of ‘void f(T) [with T = NotDerived]’:
main.cpp:22:19: required from here
main.cpp:13:9: required for the satisfaction of ‘HasBase1Or2<T>’ [with T = NotDerived]
main.cpp:13:55: note: no operand of the disjunction is satisfied
13 | concept HasBase1Or2= std::is_base_of<Base1, T>::value ||
| ~~~~~~^~
14 | std::is_base_of<Base2, T>::value;
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cc1plus: note: set ‘-fconcepts-diagnostics-depth=’ to at least 2 for more detail
在 Ubuntu 21.04 GCC 10.3.0 上测试。
GCC 10 似乎已经实现了它：https://gcc.gnu.org/gcc-10/changes.html，你可以得到它as a PPA on Ubuntu 20.04。 https://godbolt.org/ GCC 10.1 在 Ubuntu 20.04 上无法识别 concept。
【讨论】：
这在纯 C++ 中是不可能的，但您可以在编译时通过概念检查验证模板参数，例如使用Boost's BCCL。
从 C++20 开始，概念正在成为该语言的 official feature。
【讨论】：
这在 C++ 中通常是没有根据的，正如此处的其他答案所指出的那样。在 C++ 中，我们倾向于根据“从此类继承”以外的其他约束来定义泛型类型。如果你真的想这样做，在 C++11 和 <type_traits> 中很容易做到：
#include <type_traits>
template<typename T>
class observable_list {
static_assert(std::is_base_of<list, T>::value, "T must inherit from list");
// code here..
};
这打破了人们在 C++ 中所期望的许多概念。最好使用诸如定义自己的特征之类的技巧。例如，observable_list 可能想要接受任何类型的容器，该容器具有类型定义 const_iterator 以及返回 const_iterator 的 begin 和 end 成员函数。如果您将此限制为从 list 继承的类，那么拥有自己的类型但不从 list 继承但提供这些成员函数和 typedef 的用户将无法使用您的 observable_list。
这个问题有两种解决方案，其中之一是不限制任何东西并依赖鸭子类型。该解决方案的一大缺点是它涉及大量错误，用户可能难以理解。另一种解决方案是定义特征来约束提供的类型以满足接口要求。这个解决方案的一大缺点是涉及额外的写作，这可能会让人觉得很烦人。但是，积极的一面是您将能够编写自己的错误消息，例如 static_assert。
为了完整起见，给出上例的解决方案：
#include <type_traits>
template<typename...>
struct void_ {
using type = void;
};
template<typename... Args>
using Void = typename void_<Args...>::type;
template<typename T, typename = void>
struct has_const_iterator : std::false_type {};
template<typename T>
struct has_const_iterator<T, Void<typename T::const_iterator>> : std::true_type {};
struct has_begin_end_impl {
template<typename T, typename Begin = decltype(std::declval<const T&>().begin()),
typename End = decltype(std::declval<const T&>().end())>
static std::true_type test(int);
template<typename...>
static std::false_type test(...);
};
template<typename T>
struct has_begin_end : decltype(has_begin_end_impl::test<T>(0)) {};
template<typename T>
class observable_list {
static_assert(has_const_iterator<T>::value, "Must have a const_iterator typedef");
static_assert(has_begin_end<T>::value, "Must have begin and end member functions");
// code here...
};
上面的例子中展示了很多概念，展示了 C++11 的特性。一些好奇的搜索词是可变参数模板、SFINAE、表达式 SFINAE 和类型特征。
【讨论】：
template<class T:list> 是一个如此冒犯的概念。感谢您的提示。
template<typename... Args>是什么：en.cppreference.com/w/cpp/language/parameter_pack
我建议将 Boost 的 static assert 功能与 Boost Type Traits 库中的 is_base_of 结合使用：
template<typename T>
class ObservableList {
BOOST_STATIC_ASSERT((is_base_of<List, T>::value)); //Yes, the double parentheses are needed, otherwise the comma will be seen as macro argument separator
...
};
在其他一些更简单的情况下，您可以简单地前向声明一个全局模板，但只为有效类型定义（显式或部分特化）它：
template<typename T> class my_template; // Declare, but don't define
// int is a valid type
template<> class my_template<int> {
...
};
// All pointer types are valid
template<typename T> class my_template<T*> {
...
};
// All other types are invalid, and will cause linker error messages.
[次要编辑 6/12/2013：使用声明但未定义的模板将导致 链接器，而不是编译器，错误消息。]
【讨论】：
myBaseType。在关闭 Boost 之前，您应该知道其中大部分是仅包含标头的模板代码——因此对于您不使用的东西在运行时没有内存或时间成本。此外，您将在此处使用的特定内容（BOOST_STATIC_ASSERT() 和 is_base_of<>）可以仅使用 声明 （即没有实际的函数或变量的定义）来实现，所以它们也不会占用任何空间或时间。
static_assert(std::is_base_of<List, T>::value, "T must extend list")。
my_template<int> x; 或 my_template<float**> y; 并验证编译器是否允许这些，然后声明一个变量 my_template<char> z; 并验证它是否不允许。
据我所知，这在 C++ 中目前是不可能的。但是，有计划在新的 C++0x 标准中添加一个称为“概念”的功能，以提供您正在寻找的功能。这篇关于 C++ 概念的Wikipedia article 会更详细的解释。
我知道这并不能解决您当前的问题，但是有一些 C++ 编译器已经开始添加新标准的功能，因此可能会找到已经实现概念功能的编译器。
【讨论】：
static_assert 和 SFINAE 也是可能的。对于来自 Java 或 C# 或 Haskell(...) 的人来说，剩下的问题是 C++20 编译器不会针对所需的概念执行 definition checking，而 Java 和 C# 会这样做。
我们可以使用std::is_base_of 和std::enable_if:
（static_assert 可以去掉，如果不能引用type_traits，上面的类可以自定义实现或者使用boost）
#include <type_traits>
#include <list>
class Base {};
class Derived: public Base {};
#if 0 // wrapper
template <class T> class MyClass /* where T:Base */ {
private:
static_assert(std::is_base_of<Base, T>::value, "T is not derived from Base");
typename std::enable_if<std::is_base_of<Base, T>::value, T>::type inner;
};
#elif 0 // base class
template <class T> class MyClass: /* where T:Base */
protected std::enable_if<std::is_base_of<Base, T>::value, T>::type {
private:
static_assert(std::is_base_of<Base, T>::value, "T is not derived from Base");
};
#elif 1 // list-of
template <class T> class MyClass /* where T:list<Base> */ {
static_assert(std::is_base_of<Base, typename T::value_type>::value , "T::value_type is not derived from Base");
typedef typename std::enable_if<std::is_base_of<Base, typename T::value_type>::value, T>::type base;
typedef typename std::enable_if<std::is_base_of<Base, typename T::value_type>::value, T>::type::value_type value_type;
};
#endif
int main() {
#if 0 // wrapper or base-class
MyClass<Derived> derived;
MyClass<Base> base;
// error:
MyClass<int> wrong;
#elif 1 // list-of
MyClass<std::list<Derived>> derived;
MyClass<std::list<Base>> base;
// error:
MyClass<std::list<int>> wrong;
#endif
// all of the static_asserts if not commented out
// or "error: no type named ‘type’ in ‘struct std::enable_if<false, ...>’ pointing to:
// 1. inner
// 2. MyClass
// 3. base + value_type
}
【讨论】：
只接受从类型 List 派生的类型 T 的等价物看起来像
template<typename T,
typename std::enable_if<std::is_base_of<List, T>::value>::type* = nullptr>
class ObservableList
{
// ...
};
【讨论】：
我认为所有先前的答案都只见树木不见森林。
Java 泛型与模板不同；他们使用类型擦除，这是一种动态技术，而不是编译时多态，这是一种静态技术。为什么这两种截然不同的策略不能很好地融合应该是显而易见的。
与其尝试使用编译时构造来模拟运行时构造，不如让我们看看extends 的实际作用：according to Stack Overflow 和Wikipedia，extends 用于指示子类化。
C++ 也支持子类化。
您还展示了一个容器类，它以泛型的形式使用类型擦除，并扩展以执行类型检查。在 C++ 中，您必须自己完成类型擦除机制，这很简单：创建一个指向超类的指针。
让我们将它包装到 typedef 中，使其更易于使用，而不是制作一个完整的类，等等：
typedef std::list<superclass*> subclasses_of_superclass_only_list;
例如：
class Shape { };
class Triangle : public Shape { };
typedef std::list<Shape*> only_shapes_list;
only_shapes_list shapes;
shapes.push_back(new Triangle()); // Works, triangle is kind of shape
shapes.push_back(new int(30)); // Error, int's are not shapes
现在，List 似乎是一个接口，代表一种集合。 C++ 中的接口只是一个抽象类，即只实现纯虚方法的类。使用此方法，您可以轻松地在 C++ 中实现您的 java 示例，而无需任何概念或模板特化。由于虚拟表查找，它的执行速度也与 Java 风格的泛型一样慢，但这通常是可以接受的损失。
【讨论】：
好吧，您可以创建如下内容的模板：
template<typename T>
class ObservableList {
std::list<T> contained_data;
};
但是，这将使限制变得隐含，而且您不能只提供任何看起来像列表的东西。还有其他方法可以限制所使用的容器类型，例如通过使用并非在所有容器中都存在的特定迭代器类型，但这更多的是隐式限制而不是显式限制。
据我所知，在当前标准中不存在完全反映语句 Java 语句的构造。
有一些方法可以通过在模板中使用特定的 typedef 来限制您可以在您编写的模板中使用的类型。这将确保不包含该特定 typedef 的类型的模板特化编译将失败，因此您可以选择性地支持/不支持某些类型。
在 C++11 中，概念的引入应该使这更容易，但我认为它也不会完全符合您的要求。
【讨论】：
此类类型检查没有关键字，但您可以放入一些代码，至少会以有序的方式失败：
(1) 如果您希望函数模板仅接受某个基类 X 的参数，请将其分配给函数中的 X 引用。 (2) 如果您想接受函数但不接受原语，反之亦然，或者您想以其他方式过滤类，请在您的函数中调用一个（空）模板帮助函数，该函数仅为您要接受的类定义。
您也可以在类的成员函数中使用 (1) 和 (2) 来强制对整个类进行这些类型检查。
您可以将其放入一些智能宏中以减轻您的痛苦。 :)
【讨论】：
class Base
{
struct FooSecurity{};
};
template<class Type>
class Foo
{
typename Type::FooSecurity If_You_Are_Reading_This_You_Tried_To_Create_An_Instance_Of_Foo_For_An_Invalid_Type;
};
确保派生类继承 FooSecurity 结构，编译器会在所有正确的地方感到不安。
【讨论】：
Type::FooSecurity 用于模板类。如果传入模板参数的类没有FooSecurity，则尝试使用它会导致错误。可以肯定的是，如果在模板参数中传递的类没有 FooSecurity 它不是从Base 派生的。
目前还没有人提到的简单解决方案就是忽略问题。如果我尝试在需要容器类（例如向量或列表）的函数模板中使用int 作为模板类型，则会出现编译错误。粗鲁和简单，但它解决了问题。编译器将尝试使用您指定的类型，如果失败，则会生成编译错误。
唯一的问题是您收到的错误消息很难阅读。然而，这是一种非常常见的方法。标准库中充满了函数或类模板，它们期望模板类型具有某些行为，并且不做任何检查使用的类型是否有效。
如果您想要更好的错误消息（或者如果您想要捕获不会产生编译器错误但仍然没有意义的情况），您可以根据您想要使其复杂程度，使用 Boost 的静态断言或 Boost concept_check 库。
使用最新的编译器，您可以使用内置的static_assert。
【讨论】：
T 是哪个类型，这个代码是从哪里调用的？没有一些上下文，我没有机会理解该代码 sn-p。但我说的是真的。如果您尝试在没有toString 成员函数的类型上调用toString()，则会出现编译错误。
执行摘要：不要那样做。
j_random_hacker 的回答告诉您如何 做到这一点。但是，我还想指出，您应该不这样做。模板的全部意义在于它们可以接受任何兼容的类型，而 Java 样式类型约束打破了这一点。
Java 的类型约束是一个错误而不是一个特性。它们存在是因为 Java 在泛型上进行类型擦除，因此 Java 无法仅根据类型参数的值来弄清楚如何调用方法。
另一方面，C++ 没有这样的限制。模板参数类型可以是与它们一起使用的操作兼容的任何类型。不必有一个通用的基类。这类似于 Python 的“Duck Typing”，但在编译时完成。
一个展示模板强大功能的简单示例：
// Sum a vector of some type.
// Example:
// int total = sum({1,2,3,4,5});
template <typename T>
T sum(const vector<T>& vec) {
T total = T();
for (const T& x : vec) {
total += x;
}
return total;
}
这个 sum 函数可以对支持正确运算的任何类型的向量求和。它既适用于 int/long/float/double 等原语，也适用于重载 += 运算符的用户定义数字类型。哎呀，你甚至可以使用这个函数来连接字符串，因为它们支持 +=。
不需要对基元进行装箱/拆箱。
请注意，它还使用 T() 构造 T 的新实例。这在使用隐式接口的 C++ 中是微不足道的，但在具有类型约束的 Java 中实际上是不可能的。
虽然 C++ 模板没有显式类型约束，但它们仍然是类型安全的，并且不会使用不支持正确操作的代码进行编译。
【讨论】：
在 C++ 中是否有一些与 this 关键字等效的简单方法？
没有。
根据您要完成的工作，可能会有足够（甚至更好）的替代品。
我查看了一些 STL 代码（在 linux 上，我认为它是从 SGI 的实现派生的）。它有“概念断言”；例如，如果您需要一个能够理解*x 和++x 的类型，则概念断言将在无操作函数（或类似函数）中包含该代码。它确实需要一些开销，因此将其放入定义取决于#ifdef debug 的宏中可能是明智的。
如果子类关系真的是你想知道的，你可以在构造函数中断言T instanceof list（除了它在C++中的“拼写”不同）。这样，您可以测试自己的方式，避免编译器无法为您检查。
【讨论】：