blocks|key|2080646|text|您可以结合使用std::is_base_of和static_assert。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2080647|template<class+T>
class+MyClass
{
++++static_assert(+std::is_base_of<+OtherClass,+T+>::value,+"T+does+not+extend+OtherClass");

public:
++++MyClass();
};|code-block|syntax|javascript|2080648|(当然，您也可以将OtherClass作为额外的模板参数，以防止您需要更加灵活)|2080649|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/types/is_base_of^0|7|F|N|D|7|F|0|0|0|9|A|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

You can use <a href="http://en.cppreference.com/w/cpp/types/is_base_of" rel="noreferrer"><code>std::is_base_of</code></a> in combination with <code>static_assert</code>:

<pre><code>template&lt;class T&gt;
class MyClass
{
 static_assert( std::is_base_of&lt; OtherClass, T &gt;::value, "T does not extend OtherClass");

public:
 MyClass();
};
</code></pre>

(you can, of course, also make <code>OtherClass</code> an additional template parameter in case you need to be more flexible)

blocks|key|2080663|text|如果您声明一个模板类(即您使用template<class+T,+class+OtherClass>所做的)，那么您必须使用您声明的模板。由于您没有在T或OtherClass中使用MyClass，所以会得到编译器错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2080664|至于如何在T+extends+OtherClass中实现C%2B%2B，并不是很简单，因为C%2B%2B具有多重继承，但是可以在stl中使用is_base_of函数。|2080665|entityMap^0|F|Z|23|1|25|A|2I|7|0|5|K|1K|3|1Q|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|I|$]]

If you declare a templated class (ie what you did with <code>template&lt;class T, class OtherClass&gt;</code>) then you must use the templates you declare. Since you did not use <code>T</code> or <code>OtherClass</code> in <code>MyClass</code> you get the compiler error. 

As for how to implement <code>T extends OtherClass</code> in C++, its not as simple because C++ has multiple inheritance, but you can use the <code>is_base_of</code> function in <code>stl</code>

blocks|key|825002|text|通常，在C%2B%2B中，您只需使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825003|template<class+T>
class+MyClass|code-block|syntax|javascript|825004|你不需要说任何类似extends+OtherClass的话。|offset|length|style|CODE|825005|这是一个解释：|825006|在C%2B%2B和Java中，当您访问对象的方法或字段时，编译器必须确保对象表达式的静态类型支持该方法或字段，否则它将无法编译。|825007|在Java中，泛型类和方法只编译一次。编译泛型类或方法时，未知类型参数(如T)是或可能是什么类型参数。因此，要使编译器允许访问Object未提供的方法和字段，就必须进行限制。之所以有绑定T+extends+OtherClass，是因为在MyClass的某个地方，它试图访问T类型表达式上的方法或字段，该表达式由OtherClass提供。因此，此绑定允许编译器进行类型检查并成功编译.|825008|相反，在C%2B%2B中，模板化类和方法为每个不同类型的参数编译一次(称为模板的每个“实例化”)，就像编译器复制和粘贴模板代码的副本一样，并为代码中的每个T替换实际的类型参数。因此，在编译模板化类或方法时，确切地知道T是什么类型。绑定的规范(就像Java中的那样)是不必要的，因为编译器可以直接检查T是否支持给定的方法或字段。如果T是OtherClass的一个子类型，它将成功编译。如果T不是OtherClass的一个子类型，那么很可能它将没有该名称的方法或字段，即使有，它也可能没有合适的类型，因此很可能无法编译。基本上是鸭子打字。|825009|(不太可能，但有可能，您有一个不同的、无关的类型，它不是OtherClass的子类型，它的方法和字段的名称和类型与OtherClass中使用的方法和字段的名称和类型相同，并且如果您试图用该类型参数化MyClass，编译器不会抱怨它。然而，这种类型的存在可能是错误的设计，而且您不可能意外地在错误的地方使用这种类型。)|825010|entityMap^0|0|0|9|I|0|0|0|11|1|1R|6|2L|K|3A|7|3S|1|4B|A|0|21|1|2W|1|41|1|4H|1|4J|A|59|1|5C|A|0|S|A|1L|A|2R|7|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@$I|16|J|17|K|L]|$I|18|J|19|K|L]|$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1I|8|@$I|1J|J|1K|K|L]|$I|1L|J|1M|K|L]|$I|1N|J|1O|K|L]|$I|1P|J|1Q|K|L]|$I|1R|J|1S|K|L]|$I|1T|J|1U|K|L]|$I|1V|J|1W|K|L]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1X|8|@$I|1Y|J|1Z|K|L]|$I|20|J|21|K|L]|$I|22|J|23|K|L]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|X|$]]

Generally, in C++ you would just use:

<pre><code>template&lt;class T&gt;
class MyClass
</code></pre>

You don't need to say anything like <code>extends OtherClass</code>.

Here's the explanation:

In both C++ and Java, when you access a method or field of an object, the compiler must make sure that the static type of the object expression supports that method or field, or it will fail to compile.

In Java, generic classes and methods are compiled only once. When a generic class or method is compiled, it is unknown what type parameters (like <code>T</code>) are or could be. Therefore, bounds are necessary to make the compiler allow accessing methods and fields that are not provided by <code>Object</code>. The reason for having the bound <code>T extends OtherClass</code> is because somewhere in <code>MyClass</code>, it tries to access a method or field on an expression of type <code>T</code>, which is provided by <code>OtherClass</code>. Thus this bound allows the compiler to type-check and successfully compile.

In contrast, in C++, templated classes and methods are compiled once for each different type argument (called each "instantiation" of the template), as if the compiler copies and pastes a copy of the template code and substitutes the actual type argument for each occurrence of <code>T</code> in the code. Therefore, when a templated class or method is compiled, it is known exactly what type <code>T</code> is. A specification of a bound, like in Java, is unnecessary, because the compiler can directly check whether the type that <code>T</code> is supports a given method or field. If <code>T</code> is a subtype of <code>OtherClass</code>, it will successfully compile. If <code>T</code> is not a subtype of <code>OtherClass</code>, chances are that it will not have a method or field of that name, and even if it did, it may not have the right type for it, so it will likely fail to compile. It is basically duck-typing.

(It is unlikely, but possible, that you have a different, unrelated type that is not a subtype of <code>OtherClass</code>, that also has methods and fields of the same name and type as the ones in <code>OtherClass</code> that are used in <code>MyClass</code>, and if you try to parameterize <code>MyClass</code> with that type, the compiler won't complain about it. However, it is probably bad design for such a type to exist anyway, and it is unlikely you will accidentally use such a type in the wrong place.)

can someone tell me how to implement this Java-Code in C++?

<pre><code> public class MyClass&lt;T extends OtherClass&gt;{
 ....
 }
</code></pre>

I've tested this in C++:

<pre><code> template&lt;class T, class OtherClass&gt;
 class MyClass
 {
 public:
 MyClass();
 }
</code></pre>

But I've get the error:<code>invalid use of template-name 'MyClass' without an argument list</code>

Greetings

How to implement MyClass<T extends OtherClass> in C++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有人能告诉我如何在C++中实现这个Java吗？ public class MyClass<T extends OtherClass>{ .... }我已经在C++中测试过这个： template<class T, class OtherClass> class MyClass { public: ...

问如何在MyClass<T扩展OtherClass>中实现C++？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在MyClass<T扩展OtherClass>中实现C++？EN