C ++：我可以在模板参数包中强制执行至少1个参数

Question

This is more of a design constraint I am considering. This snippet of code is targeting the Unreal Engine in case you are wondering about the syntax - but that should be irrelevant to the question.

This template code simply takes the types of objects the user wants instantiated - it then creates an owning container object and calls the add method on the owner. (The owner is responsible for the actual construction logic)

template<typename T>
void UEntityFactory::Create_Impl(AEntityObject* owner)
{
    static_assert( TPointerIsConvertibleFromTo<T, UEntity>::Value, "[UEntityFactory] ERROR: Attempting to create a non-entity type");
    owner->AddEntity<T>();
}

// Templated create accepting variadic arguments; it first creates the housing entity object
// and then recursively generates code for each argument.
template <typename T, typename...Args>
AEntityObject* UEntityFactory::Create()
{
    // Create the owning EntityObject
    AEntityObject* obj = NewObject<AEntityObject>(this);
    Create_Impl<T>(obj);

    // Recursively call Create_Impl for Args
    Create_Impl<Args...>(obj);
    return obj;
}

From what I understood from template parameter packs, the variadic argument (...Args in my case) is optional. The rationale behind having two typenames as opposed to one parameter pack was to ensure that the user at LEAST passes one template argument.

I want to restrict the creation process to ensure a valid object is always created. But the code above does not compile if I invoke a line such as:

AEntityObject* obj = factory.Create<EntityA>();

I think with how I set my template declaration, it requires another argument. The error is as follows:

• ' UEntityFactory::Create_Impl ': no matching overloaded function found
• note: see reference to function template instantiation ' AEntityObject *UEntityFactory::Create<UDebugEntityA,>(void) ' being compiled
• ' void UEntityFactory::Create_Impl(AEntityObject *) ': could not deduce template argument for 'T'

This is one of those errors that I kinda know why it happens but I cannot articulate it. Surely enough, if I change the declaration of the Create function to the below, it compiles fine:

template <typename...Args>
AEntityObject* UEntityFactory::Create()
{
    AEntityObject* obj = NewObject<AEntityObject>(this);

    // Recursively call Create_Impl for Args
    Create_Impl<Args...>(obj);
    return obj;
}

However the implications of this is, the user can now write

AEntityObject* obj = factory.Create<>();

Which is what I want to avoid. Is there an elegant way to force at least one template argument, alongside an optional set variadic argument? I cannot overload the Create method as that will create an ambiguous call.

EDIT: I messed up, I falsely assumed my parameters were being unfolded correctly to begin with - thanks Jarod42 for correcting.

Answer 1

Well, you could just add a static_assert() to do the check and also issue a more meaningful compile-time error:

template <typename...Args>
AEntityObject* UEntityFactory::Create()
{
    static_assert(sizeof...(Args) > 0, "Create() would like to have at least one object type to create...");

    AEntityObject* obj = NewObject<AEntityObject>(this);

    // Recursively call Create_Impl for Args
    Create_Impl<Args...>(obj);
    return obj;
}

Answer 2

template <typename T, typename...Args>
AEntityObject* UEntityFactory::Create()
{
    // [..]

    // Recursively call Create_Impl for Args
    Create_Impl<Args...>(obj);
}

Is not a recursive call

So in fact it seems you have difficulty to iterate over your variadic template.

You might then use:

template <typename T, typename...Args>
AEntityObject* UEntityFactory::Create()
{
    // Create the owning EntityObject
    AEntityObject* obj = NewObject<AEntityObject>(this);
    Create_Impl<T>(obj);

    // C++17: folding expression
    (Create_Impl<Args>(obj), ...);

    return obj;
}

and before:

template <typename T, typename...Args>
AEntityObject* UEntityFactory::Create()
{
    // Create the owning EntityObject
    AEntityObject* obj = NewObject<AEntityObject>(this);
    Create_Impl<T>(obj);

    const int dummy[] = { 0, (Create_Impl<Args>(obj), 0)...};
    static_cast<void>(dummy); // Avoid warning for unused variable

    return obj;
}