How to change/set template parameter based on type?

I want to create a static class, which will act as fixed size memory allocator.

Lets look at this simplified example:

struct A {};
struct B {};

template<class T, std::size_t MaxNumObjects>
class InternalContainer
{
public:
    static constexpr std::size_t maxObjects = MaxNumObjects;

    static T* createObject()
    {
        return ::new(&objects[idx++]) T;
    }
    static T* releaseObject() { /*...*/ };

private:
    using buffer_t = std::aligned_storage_t<sizeof(T), alignof(T)>;
    static buffer_t objects[maxObjects];
    static std::size_t idx;
};

A* a = InternalContainer<A, 2>::createObject();
B* b = InternalContainer<B, 5>::createObject();

How can I predefine the maximum size of the container based on type?

// will be replaced "InternalContainer<A, 2>"
A* a = MyContainer<A>::createObject(); 

// will be replaced "InternalContainer<B, 5>"
B* b = MyContainer<B>::createObject();

I have tried something like this, but it does not work:

template<class T>
using MyContainer = InternalContainer<A, 2>;
template<class T>
using MyContainer = InternalContainer<B, 5>;

> How can I predefine the maximum size of the container based on type?

You have several options here.
The easiest, would be providing a specialization for the default types (i.e. A, B )

template <class T> struct MyContainer;
// specialization for A
template <> struct MyContainer<A> {
    using type = InternalContainer<A, 2>;
};
// specialization for B
template <> struct MyContainer<B> {
    using type = InternalContainer<B, 5>;
};
// ... so on!

// Helper alias
template <class T>
using MyContainer_t = typename MyContainer<T>::type;

static_assert(std::is_same_v<MyContainer_t<A>, InternalContainer<A, 2>>);

See live demo in godbolt.org

Alternatively, using if constexpr (requires [tag:C++17] or higher) you might be able to do something like as follows:

#include <type_traits>

template <class T>
constexpr auto typeHelper()
{
    // following requires the InternalContainer<T, N> be default constructible!!
    if constexpr (std::is_same_v<T, A>) return InternalContainer<A, 2>{};
    else if constexpr (std::is_same_v<T, B>) return InternalContainer<B, 5>{};
}

template <class T>
using MyContainer = decltype(typeHelper<T>());

A* a = MyContainer<A>::createObject(); // will be replaced b InternalContainer<A, 2>
B* b = MyContainer<B>::createObject(); // will be replaced b InternalContainer<B, 5>

See live demo in godbolt.org

Alternatively, using std::conditional_t you could do also

#include <type_traits> //  std::conditional_t

template <class T>
using MyContainer = std::conditional_t<std::is_same_v<T, A>, InternalContainer<A, 2>,
    std::conditional_t<std::is_same_v<T, B>, InternalContainer<B, 5>,
    /*Default case if types are not A nor B*/ void>
>;

See live demo in godbolt.org

This can be easily accomplished by explicitly specializing a variable template, e.g.:

godbolt example

struct A {};
struct B {};
struct C {};

// default size for all InternalContainers
template<class T>
constexpr std::size_t InternalContainerDefaultSize = 64;
// specialization for A
template<>
constexpr std::size_t InternalContainerDefaultSize<A> = 2;
// specialization for B
template<>
constexpr std::size_t InternalContainerDefaultSize<B> = 5;

template<class T, std::size_t MaxNumObjects = InternalContainerDefaultSize<T>>
class InternalContainer {
    /* ... */
};


InternalContainer<A> aContainer; // size will be 2
InternalContainer<B> bContainer; // size will be 5
InternalContainer<C> cContainer; // size will be 64

// default size can be overriden by explicitly specifying another size
InternalContainer<A, 10> aContainer; // size will be 10