c++ - 使用不同的模板参数转换模板对象，这怎么可能？

Question

今天我尝试了一些方法，认为它不起作用，但它确实起作用，我不明白为什么......

我有一个 base 类型的对象其中什么都不包含。
另一种类型 derived它继承自 base ，存储函数指针并调用它。
derived是一个模板对象，它的参数是存储的函数等待的参数类型。

如果我引用 base 类型来自 derived<void> 类型的对象并尝试将其转换到 derived<int> ...它确实有效。
你怎么解释derived<>和derived< int >是两种不同的类型吗？

一个简单的例子:

#include <iostream>

void foo( int ) { ::std::cout << "void foo( int )\n"; }
void foo() { ::std::cout << "void foo()\n"; }

struct base
{
  base() { ::std::cout << "\tcreate base\n"; }
  base( const base & ) { ::std::cout << "\tcopy base\n"; }
  base( base && ) { ::std::cout << "\tmove base\n"; }

  void operator =( const base & ) { ::std::cout << "\tcopy assignment base\n"; }
  void operator =( base && ) { ::std::cout << "\tmove assignment base\n"; }
};

template < typename ... Args >
struct derived : public base
{
  derived() { ::std::cout << "\tcreate derived\n"; }
  derived( const derived & ) { ::std::cout << "\tcopy derived\n"; }
  derived( derived && ) { ::std::cout << "\tmove derived\n"; }

    derived & operator =( const derived & ) { ::std::cout << "\tcopy assignment derived\n"; }
  derived & operator =( derived && ) { ::std::cout << "\tmove assignment derived\n"; }

  void operator ()( Args ... args )
  {
    f( args ... );
  }

  void ( *f )( Args ... );
};


int main()
{
  derived<> derived_void;
  derived_void.f = ( void ( * )() )&foo;

  base & base_void = derived_void;
  derived<> &test = derived_void;

  static_cast< derived< int > & >( base_void )( 1 ); // compiles, makes no copy
//  static_cast< derived< int > & >( test )( 1 ); // doesn't compile
}

You can test it here.

感谢您的帮助。

Answer 1

忘记模板。

您有一个类 A、一个派生自 A 的类 B 和一个派生于 A 的类 C派生自A。

如果您有 A 类型的左值，则可以将其转换为 B & 或 C &。编译器通常无法知 Prop 体的派生类型是什么，因此它相信您知道自己在做什么。

这正是您正在做的:将 A 转换为 B &。您的 A 实际上是一个 C 对象，但编译器不知道这一点。