How do I have a template class object as a member of a non-template class in C++?

I'm relatively new to templates in C++, and I'm having trouble understanding how to handle the following situation. I'm given a template class Reader that deduces its arguments from a template class Layout object passed to the constructor, like this:

template<typename ...Args>
class Layout {};

template<typename ...Args>
class Reader {
  public:
	Reader(Layout<Args...> layout);
};

Given a specific instantiation of Layout:

using ALayout = Layout<int, double>;

I would like to create a new, non-template class AReaderHolder that has a member variable of type Reader with ALayout as its layout. How can I do this without making AReaderHolder itself a class template?

I tried this:

class AReaderHolder {
  public:
   	AReaderHolder() :
      _reader{ALayout{}} {}

  private:
    Reader _reader;
}

and got this error:

> use of class template 'Reader' requires template arguments;
> argument deduction not allowed in non-static class member

Which is fair, but what should I put for template arguments for the declaration for _reader? The problem as I see it is that Reader is templated on the parameter pack passed to Layout, and I don't know how to reference just that...

EDIT:
I recognize that I could just do something like

using AReader = Reader<int, double>;

And then just declare _reader to be of type AReader. But it feels clunky to manually specify the same parameter pack for ALayout and AReader (imagine the parameter pack is quite long and complex). Is there a way to do something like:

K = ???;
using ALayout = Layout<K>;
using AReader = Reader<K>;

To guarantee that ALayout and AReader are using the same parameter pack?

Sticking to the plan of making an AReader alias:

class AReaderHolder {
    AReader _reader;
public:
    AReaderHolder() : _reader{ALayout{}} { }
};

The question is how to define AReader neatly.

You could try to use class template argument deduction:

using AReader = decltype(Reader(std::declval<ALayout>()));
// this line says: "Imagine you have an ALayout. Then imagine making a Reader from this imaginary object. Take the type of this imaginary Reader and call it AReader."

This depends on Reader having template-deduction friendly constructors/deduction guides. For the skeleton you've posted, this works.

Another idea is to have Layout itself expose the correct Reader type:

template<typename ...Args>
class Reader; // necessary forward declaration

template<typename... Args>
struct Layout {
    using ReaderType = Reader<Args...>;
};

using AReader = ALayout::ReaderType;

A robust solution that doesn't involve changing Layout is a type trait:

template<typename T>
struct ReaderForLayout;
template<typename... Args>
struct ReaderForLayout<Layout<Args...>> { using type = Reader<Args...>; };
template<typename T>
using ReaderForLayout_t = typename ReaderForLayout<T>::type;

using AReader = ReaderForLayout_t<ALayout>;

(If I ever found myself writing a type trait like this one, though, I would reconsider my design choices.)

You just need to explicitly declare the template parameter for Reader.

class AReaderHolder
{
    public:
        AReaderHolder() :
            _reader{ALayout{}}
  {}

    private:
        Reader<Layout<int,double>> _reader;
}

Looking at cpp / class template, I see the issue comes from the fact that Reader is a template class, and it requires template arguments when you are declaring an instance of it in your AReaderHolder class.

In your case, since you have already defined ALayout as Layout<int, double>, you can use it as the template argument for Reader.

For instance:

class AReaderHolder
{
    public:
        AReaderHolder() :
            _reader{ALayout{}}
        {}

    private:
        Reader<int, double> _reader; // Using ALayout template arguments here
};

In the above code, _reader is an instance of Reader<int, double>, because ALayout is an alias for Layout<int, double>.
This way, AReaderHolder does not need to be a template class, and the template arguments for Reader are provided explicitly based on your ALayout definition.

The reason we have Reader<int, double> _reader; instead of Reader<Layout<int, double>> _reader; has to do with how the Reader class template is defined.

Looking at your initial Reader definition:

template<typename ...Args>
class Reader 
{
  public:
	Reader(Layout<Args...> layout);
};

The template parameters for Reader are not a Layout object, but rather the types that are used to instantiate Layout. In the constructor, an object of Layout<Args...> is passed, but the Args... in Reader and Layout are the same.

So, when we instantiate Reader, we need to provide the types that we would use to instantiate Layout, not the Layout itself. Therefore, we use Reader<int, double> _reader; because int and double are the types that are used to instantiate Layout (i.e., ALayout).

To resume: AReaderHolder is a non-template class that has a member variable _reader of type Reader<int, double>. This Reader<int, double> is the instantiation of the Reader template class that corresponds to the Layout<int, double> or ALayout that you have defined.

To be more precise, if you want to make sure that _reader is specifically associated with ALayout, you could potentially define a type alias for Reader<int, double> and use that in AReaderHolder:

using AReader = Reader<int, double>;

class AReaderHolder
{
    public:
        AReaderHolder() :
            _reader{ALayout{}}
        {}

    private:
        AReader _reader;
};

This way, it's clear that _reader is the version of Reader that corresponds to ALayout. However, under the hood, AReader is still an instantiation of the Reader template class with the same arguments as ALayout.

> Is there a way to do something like:
> cpp
> K = ???;
> using ALayout = Layout<K>;
> using AReader = Reader<K>;
>
> To guarantee that ALayout and AReader are using the same parameter pack?

I do not think you can assign a type (or a set of types, in the case of a parameter pack) to a variable like K in your example.

Maybe a type alias would help in your case:

template<typename ...Args>
using ALayout = Layout<Args...>;

template<typename ...Args>
using AReader = Reader<Args...>;

// Now you can define your types as
using MyLayout = ALayout<int, double>;
using MyReader = AReader<int, double>;

In this example, MyLayout and MyReader are both using the same parameter pack, and you only have to specify it once.
If you need to change the parameter pack, you only have to change it in one place.
However, note that MyLayout and MyReader are still separate types, and changing the definition of one will not automatically change the other.

Reading about type trait, I suppose you can use a type trait to extract the types from the Layout and use them to define Reader.
A type trait is a template that operates on types, and it can be used to define type transformations or to extract information about a type.

For your case, you can define a type trait that extracts the parameter pack from Layout and applies it to Reader, like:

template<typename T>
struct LayoutToReader;  // Forward declaration

template<typename ...Args>
struct LayoutToReader<Layout<Args...>> {
    using type = Reader<Args...>;
};

// Now you can define AReader like this:
using AReader = LayoutToReader<ALayout>::type;

In this example, LayoutToReader is a type trait that transforms a Layout into a corresponding Reader. It does this by specializing for Layout<Args...> and defining a type member that is Reader<Args...>. Then, you can use this type trait to define AReader based on ALayout.

This way, you don't need to manually specify the same parameter pack for ALayout and AReader. If ALayout changes, AReader will automatically change to match it. This is a more robust solution that works even if the parameter pack is long and complex.

Perhaps a simpler approach than the so far suggested would be to parameterize Reader not on ...Args but on Layout:

template <typename Layout>
class Reader { /* ... */ };

Then you can just instantiate Reader on ALayout:

class AReaderHolder {
  public:
    AReaderHolder() :
      _reader{ALayout{}} {}

  private:
    Reader<ALayout> _reader;
};

If you need access to the template arguments ...Args of ALayout in the definition of Reader, you can specialize it and leave the primary template undefined:

template <typename Layout>
class Reader;

template <typename... T>
class Reader<Layout<T...>> { /* Here you have access to `...Args` */ };