Nested Template Classes

I want to be able to create a generic nested template such that I can find the total size of all classes. To start, imagine for classes A, B, C, etc... each of which have a mSize member, and GetSize() function. I do the following process:

int main()
{
    using Abc = A<B<C<>>>;  // Imagine it is defined similarly to this for now.
    Abc abc;

    std::cout << abc.GetSize() << std::endl;

    // For abc.GetSize(), this will do the following:
    // 1. Go into A::GetSize().
    // 2. This will return A::mSize + B::GetSize()
    // 3. This will go into B::GetSize()
    // 4. This will return B::mSize + C::GetSize()
    // 5. Etc
    // Overall, we will have the total size of A+B+C as
    // A::mSize + B::mSize + C::mSize.

    return 0;
}

It will recursively go through each template class until the end and call GetSize(). My current attempts to do so have been using template-templates and variadic templates.

template <template<typename> class First, template<typename> class ...Args>
class A
{
public:
    int GetSize() const
    {
        First<Args...> foo;
        return mSize + foo.GetSize();
    }
private:
    int mSize{1};
};

template <template<typename> class First, template<typename> class ...Args>
class B
{
public:
    int GetSize() const
    {
        First<Args...> foo;
        return mSize + foo.GetSize();
    }
private:
    int mSize{2};
};

template <template<typename> class First, template<typename> class ...Args>
class C
{
public:
    int GetSize() const
    {
        First<Args...> foo;
        return mSize + foo.GetSize();
    }
private:
    int mSize{3};
};

This obviously has not worked. I would really like to be able to achieve the process described in int main().

Notes:

1. These classes don't necessarily have to be included, or be in order. We could have A<C> or B<E<C<F<>>>>. Ideally, it can be infinitely long.

2. I don't want to use polymorphism, wanting it to be resolved at runtime. I could have them all inherit from the same class, create a std::vector<Parent*>, push_back each child class, and iterate through using GetSize(). It would be nice to be able to define unique types such as A<B<>>, A<B<C<>>>, etc.