使用兼容C++11的编译器，您可以执行以下操作：

template<class Derived> class MyClass {

    MyClass() {
        // Compile-time sanity check
        static_assert(std::is_base_of<BaseClass, Derived>::value, "Derived not derived from BaseClass");

        // Do other construction related stuff...
        ...
   }
}

我已经在CYGWIN环境中使用gcc 4.8.1编译器对此进行了测试-所以它在 *nix环境中也应该工作。

在这种情况下，您可以执行以下操作：

template <class T> void function(){
    Baseclass *object = new T();

}

如果T不是Baseclass的子类（或者T * 是 * Baseclass），则不会编译。

要在运行时执行更少的无用代码，可以查看：www.example.com，它提供了一些类，可以有效地执行编译时测试，并生成更好的错误消息。http://www.stroustrup.com/bs_faq2.html#constraints which provides some classes that perform the compile time test efficiently, and produce nicer error messages.
特别是：

template<class T, class B> struct Derived_from {
        static void constraints(T* p) { B* pb = p; }
        Derived_from() { void(*p)(T*) = constraints; }
};

template<class T> void function() {
    Derived_from<T,Baseclass>();
}

C11引入了is_base_of和enable_if，C14引入了方便的类型enable_if_t，但是如果你坚持使用C++11，你可以简单地使用enable_if::type。

备选方案1

David Rodríguez的解决方案可以重写如下：

#include <type_traits>

using namespace std;

template <typename T>
enable_if_t<is_base_of<Base, T>::value, void> function() {
   // This function will only be considered by the compiler if
   // T actualy derived from Base
}

备选方案2

从C++17开始，我们有is_base_of_v，解可以进一步改写为：

#include <type_traits>

using namespace std;

template <typename T>
enable_if_t<is_base_of_v<Base, T>, void> function() {
   // This function will only be considered by the compiler if
   // T actualy derived from Base
}

备选方案3

你也可以只限制整个模板。你可以使用这个方法来定义整个类。注意enable_if_t的第二个参数是如何被移除的（它之前被设置为void）。它的默认值实际上是void，但这并不重要，因为我们没有使用它。

#include <type_traits>

using namespace std;

template <typename T,
          typename = enable_if_t<is_base_of_v<Base, T>>>
void function() {
   // This function will only be considered by the compiler if
   // T actualy derived from Base
}

从模板参数的documentation中，我们看到typename = enable_if_t...是一个空名称的模板参数，我们只是使用它来确保类型的定义存在，特别是，如果Base不是T的基，enable_if_t将不会被定义。
上面的技术在enable_if中作为示例给出。

您不需要概念，但可以使用SFINAE：

template <typename T>
boost::enable_if< boost::is_base_of<Base,T>::value >::type function() {
   // This function will only be considered by the compiler if
   // T actualy derived from Base
}

请注意，这将仅在满足条件时示例化函数，但如果不满足条件，则不会提供明显的错误。

您可以使用Boost Concept Check的BOOST_CONCEPT_REQUIRES：

#include <boost/concept_check.hpp>
#include <boost/concept/requires.hpp>

template <class T>
BOOST_CONCEPT_REQUIRES(
    ((boost::Convertible<T, BaseClass>)),
(void)) function()
{
    //...
}

从C++20开始，你可以约束模板参数。一种方法是requires子句。你可以在你的情况下使用它如下（即确保T是一个特定类Baseclass的子类）：

template <class T> void function()
   requires( std::is_base_of_v<Baseclass,T> )
{
   T *object = new T();
}

或者，对于频繁使用的约束，可以使用命名概念，这样语法更简洁（@sklott的功劳）：

template <std::derived_from<Baseclass> T> void function()
{
   T *object = new T();
}

使用约束比使用static_assert好，因为它们允许您拥有function的多个实现，这些实现具有不同的约束。例如，当T从不同的类派生时，您可以拥有另一个实现。如果需要，您还可以拥有一个根本不指定任何约束的默认实现。当没有一个受约束的实现符合条件时由编译器选择。使用static_assert时，这些都不可能。
PS. requires子句非常适合于特殊约束，而命名概念非常适合于频繁使用的约束（您也可以使用concept关键字创建您自己的命名概念）。您可以阅读更多关于约束和应用它们的替代方法here、关于std::is_base_of_vhere和关于std::derived_fromhere。还请务必阅读有关requires expressions的内容，不要将其与requires子句混淆，即使它们共享相同的requires关键字。

通过调用存在于基类中的模板内的函数。
如果尝试使用无权访问此函数的类型示例化模板，则将收到编译时错误。