使用typedef表示unique_ptr模板

Question

The following code compiles.

matrix.h before template

template<typename T>
class Matrix
{
public:
    //...
    unique_ptr<Matrix<T>> Test() const;
};

matrix.cpp before template

template<typename T>
unique_ptr<Matrix<T>> Matrix<T>::Test() const
{
    unique_ptr<Matrix<T>> a{ new Matrix<T>{ 1, 1 } };
    return std::move(a);
}

I wanted to use a typedef (using) to shorten things as I thought it'd be more readable but my changes cause errors. Here are the relevant changes.

matrix.h after template

template<typename T>
class Matrix
{
public:
    //...
    MatrixUniq<T> Test() const;
};

template<class T> using MatrixUniq = unique_ptr<Matrix<T>>;

matrix.cpp after template

template<typename T>
MatrixUniq<T> Matrix<T>::Test() const
{
    MatrixUniq<T> a{ new Matrix<T>{ 1, 1 } };
    return std::move(a);
}

Compiling after these changes are made crashes the VC++ compiler twice, but also generates a few errors:

Error   C2143   syntax error: missing ';' before '<'    
Error   C4430   missing type specifier - int assumed. 
Error   C2238   unexpected token(s) preceding ';'
Error   C1903   unable to recover from previous error(s);

What's wrong with my typedef implementation? Thanks.

Edit: I'm using VS2015. I'm building a static library. At the bottom of matrix.cpp I have:

template class VMatrix<double>;

Answer 1

You are using the MatrixUniq<T> alias before having defined it.

Move the using inside the class:

template<typename T>
class Matrix
{
public:
    template<class U> using MatrixUniq = std::unique_ptr<Matrix<U>>;

    MatrixUniq<T> Test() const;
};

And change the definition accordingly:

template<typename T>
Matrix<T>::MatrixUniq<T> Matrix<T>::Test() const
{
    return MatrixUniq<T>{ new Matrix<T>{ 1, 1 } };
}

Or if you want to have it in the global namespace, define it before the class definition after a forward declaration on the class:

template<typename T>
class Matrix;

template<class T> using MatrixUniq = std::unique_ptr<Matrix<T>>;

template<typename T>
class Matrix
{
public:
    //...
    MatrixUniq<T> Test() const;
};

Also you don't need to explicitly do a std::move when returning local variables. Local variables that are returned are automatically moved by default.

Answer 2

try this:

template<typename T>
class Matrix
{
public:
    using unique_ptr_type = std::unique_ptr<Matrix>;
    //...
    unique_ptr_type Test() const;
};

template<class T> using MatrixUniq = typename Matrix<T>::unique_ptr_type;

template<typename T>
typename Matrix<T>::unique_ptr_type Matrix<T>::Test() const
{
    return unique_ptr_type(new Matrix());
}

Answer 3

Always make sure to declare templates above the code which will be using it.

Also this snippet:

template<class T> using MatrixUniq = unique_ptr<Matrix<T>>;

might not be a correct implementation.

Here's how you can declare a type definition in c++.

typedef <type> <var_name>

Here's another example using an 'Alias Template'

template<typename T>
using MyVector = std::vector<T, MyCustomAllocator<T>>;

The rest of the code is for you to debug.

See this relevant discussion here:

How to typedef a template class?