How to create concrete class from a template class

Say I have a template class:

template <typename T> class StringDeque:
public std::deque<T>
{
public:

    ...

private:
    typedef std::deque<T> BaseClass; 
};

Say I want to create concrete class ArrayString where T=std::string. What is the proper way to achieve that:

define

#define ArrayString StringDeque<string>

typedef

typedef StringDeque < string > ArrayString;

inheritance

class ArrayString :
    public StringDeque < string > {};

I'm not sure whether all of the suggestions are valid. Anyway I'm trying to figure out which practice most fits.

Proper ways:

typedef std::deque<std::string> StringDeque;
using StringDeque = std::deque<string>;

That said, here are some more notes on your question:

You wrote:

template <typename T> class StringDeque: public std::deque<T> // ...

std container classes are not meant as base classes. This means they should not be inherited from (and inheriting from them is UB).

When you want to use std container functionality in another class, the answer should always be encapsulation. That means, the correct way to build on the functionality of std::queue in your classes is:

template<typename T> class StringDequeue {
    std::deque<T> storage;
public:
    // add interface here that uses storage
};

You also proposed this:

#define ArrayString StringDeque<string>

Please never use define to declare a type. It works, but it has it's own pitfalls and is considered bad practice in C++.