Select a method as (default) template parameter

I found a solution for my problem. However, I get warnings

warning C4127: conditional expression is constant

in the adjust() method for the if(std::is_same... and I was wondering if this is normal or if I can get rid of it, other than disabling it.

#include "stdafx.h"
#include "windows.h"

#include <iostream>
#include <cstring>
#include <type_traits>

#pragma warning (push)
//#pragma warning (disable : 4127)

typedef unsigned int        uint_t;
typedef signed int          int_t;

typedef struct { const static bool _virtual_allocator = true; } _virtual_type;
typedef struct { const static bool _aligned_allocator = true; } _aligned_type;
typedef struct { const static bool _malloc_allocator = true; } _malloc_type;

template <typename T, typename S, typename _allocator = _aligned_type>
class Container
{
public:
    Container(S nItems = 0, S nMaxItems = 0, T *pArray = NULL)
    {
        mItems = nItems;
        mMaxItems = nMaxItems;
        mArray = pArray;
    }

    void adjustMalloc(uint_t nClusterSize)
    {
        if(mItems == mMaxItems)
        {
            mArray = (T *)realloc(mArray, (mMaxItems+nClusterSize)*sizeof(T));
            mMaxItems += nClusterSize;
        }
    }

    void adjustAligned(uint_t nClusterSize)
    {
        if(mItems == mMaxItems)
        {
            mArray = (T *)_aligned_realloc(mArray, (mMaxItems+nClusterSize)*sizeof(T), 16);
            mMaxItems += nClusterSize;
        }
    }

    void adjustVirtual(uint_t nClusterSize)
    {
        if(mItems == mMaxItems)
        {
            mArray = (T *)VirtualAlloc((LPVOID)mArray, (mMaxItems+nClusterSize)*sizeof(T), MEM_RESERVE, PAGE_NOACCESS);
            mMaxItems += nClusterSize;
        }
    }

    void adjust(uint_t nClusterSize)
    {
        if (std::is_same<_allocator, _virtual_type>::value)
            adjustVirtual(nClusterSize);
        else if(std::is_same<_allocator, _aligned_type>::value)
            adjustAligned(nClusterSize);
        else if(std::is_same<_allocator, _malloc_type>::value)
            adjustMalloc(nClusterSize);
        else
        {
            // Cause a static compiler error, how?
        }
    }

    bool add(T *pItem)
    {
        if(find(pItem) == NULL)
        {
            adjust(100);
            mItems++;

            return true;    // added
        }

        return false;
    }

    T *find(T *pItem)
    {
        T *p = mArray;

        for(S i = 0; i < mItems; i++, p++)
        {
            if(*p == *pItem)
                return p;
        }

        return NULL;
    }

private:
    S mItems;
    S mMaxItems;
    T *mArray;
};

#pragma warning (pop)

class Record
{
public:
    bool operator==(const Record &oRecord)
    {
        if(Id != oRecord.Id)
            return false;

        if(strcmp(Name, oRecord.Name) != 0)
            return false;

        return true;
    }

    int Id;
    char Name[10+1];
};

int main(int argc, char *argv[])
{
    Record rec;
    rec.Id = 0;
    strcpy(rec.Name, "Test");

    Container<Record, uint_t> mrecords;
    mrecords.add(&rec);

    if(mrecords.find(&rec) == NULL)
        std::cerr << "Malloc Not found" << std::endl;

    Container<Record, uint_t, _aligned_type> arecords;
    arecords.add(&rec);

    if(arecords.find(&rec) == NULL)
        std::cerr << "Aligned Not found" << std::endl;

    Container<Record, uint_t, _virtual_type> vrecords;
    vrecords.add(&rec);

    if(vrecords.find(&rec) == NULL)
        std::cerr << "Virtual Not found" << std::endl;

    return 0;
}