'using type' in C++ causes several errors

Question

In my question type as returntype in c++ I was provided with an answer that gave me such a structure:

template <int N>
struct int_type {
    using type = std::conditional_t<N <= 8, std::uint8_t,
                 std::conditional_t<N <= 16, std::uint16_t,
                 std::conditional_t<N <= 32, std::uint32_t,
                 std::conditional_t<N <= 64, std::uint64_t,
                 std::uintmax_t>>>>;
};

That seemed to do excactly what I need, how ever the practice looks different, since I can't compile it because of the following errors:

...Error: expected nested-name-specifier before 'type'
 using type = std::conditional_t<N <= 8, std::uint8_t,
       ^
...Error: using-declaration for non-member at class scope
...Error: expected ';' before '=' token
 using type = std::conditional_t<N <= 8, std::uint8_t,
            ^
...Error: expected unqualified-id before '=' token

I tried to google it, but none of the posts I found seem to adress this specific problems. Can anyone explain me what is wrong with this code? I'm pretty new to C++

`conditional_t` is a helper type introduced in C++14. Are you compiling with `-std=c++14` flag? — vsoftco, Dec 14 '14 at 15:45
@PeterT that's the thing, `std::conditional_t` is a typedef for the `conditional::type` http://en.cppreference.com/w/cpp/types/conditional — vsoftco, Dec 14 '14 at 15:47
clearly, the error indicates you didn't even enable C++11, not to mention C++14 required for `std::conditional_t`. It expects *using-declaration* syntax, hence the error where compiler wants *nested name specifier* after `using` — Piotr Skotnicki, Dec 14 '14 at 15:49
@TreeOfLife what compiler? and shouldn't you add `CONFIG+=-std=c++14` ? — Piotr Skotnicki, Dec 14 '14 at 15:55
I just googled, aparently c++14 features aren't all supported with my version of MinGW (4.8)...http://stackoverflow.com/questions/26127217/how-can-i-use-c14-features-when-building-qmake-projects — TreeOfLife, Dec 14 '14 at 15:59
@TreeOfLife try [this](http://coliru.stacked-crooked.com/a/ecf9c9d28c00b981) instead — Piotr Skotnicki, Dec 14 '14 at 16:01
This gives me another error, 'uint8_t' is not a member of 'std' using type = typename std::conditional — TreeOfLife, Dec 14 '14 at 16:09
@TreeOfLife `stdint.h` might not define those typedefs in `std` namespace — Piotr Skotnicki, Dec 14 '14 at 16:19
@PiotrS. can you add your code and what you explained put into an answer, so that I can mark it? That all together fixed the problem, thank you very much. — TreeOfLife, Dec 14 '14 at 16:20

Piotr Skotnicki · Accepted Answer · 2020-05-25T06:28:00.513

Your code is perfectly legal as long as your compiler supports c++14 stdlib's <type_traits> that define an alias template for std::conditional trait.

However, the error message clearly indicates you've not even enabled c++11, therefore using is not parsed as an alias at all. To do that, add -std=c++11 or -std=c++14 option to your configuration.

If you can't, then in c++03 you can easily implement your own conditional trait:

template <bool B, typename T, typename F>
struct conditional
{
    typedef T type;
};

template <typename T, typename F>
struct conditional<false, T, F>
{
    typedef F type;
};

template <int N>
struct int_type {
    typedef typename conditional<N <= 8, uint8_t,
                 typename conditional<N <= 16, uint16_t,
                 typename conditional<N <= 32, uint32_t,
                 typename conditional<N <= 64, uint64_t,
                 uintmax_t>::type>::type>::type>::type type;
};

In c++11 you can use std::conditional instead of std::conditional_t, the only difference is that you need to access a nested typedef type on your own, which is a dependent name (typename keyword needed in front of a nested name specifier):

#include <cstdint>
#include <type_traits>

template <int N>
struct int_type {
    using type = typename std::conditional<N <= 8, std::uint8_t,
                 typename std::conditional<N <= 16, std::uint16_t,
                 typename std::conditional<N <= 32, std::uint32_t,
                 typename std::conditional<N <= 64, std::uint64_t,
                 std::uintmax_t>::type>::type>::type>::type;
};

In c++11 and c++14, you need to include <cstdint> instead of <stdint.h>. The former guarantees the names are defined in the std namespace (the latter may define them only in the global namespace).

score 0 · Answer 2 · answered Dec 14 '14 at 16:20

I'll add an answer here for the sake of completeness.

You need to #include <cstdint> and #include <type_traits>, then compile with C++14 support. Code:

#include <type_traits>
#include <cstdint>
#include <iostream>

template <int N>
struct int_type {
    using type = std::conditional_t<N <= 8, std::uint8_t,
                 std::conditional_t<N <= 16, std::uint16_t,
                 std::conditional_t<N <= 32, std::uint32_t,
                 std::conditional_t<N <= 64, std::uint64_t,
                 std::uintmax_t>>>>;
};

int main()
{
    int_type<10>::type t; // std::uint16_t
    t = 12;
    std::cout << t << std::endl;
}

Live example: http://coliru.stacked-crooked.com/a/9352f3349f48bff4

score -1 · Answer 3 · answered Dec 14 '14 at 15:57

-1

Huh, when you do a typedef the compiler tells you what's wrong. Those are dependant typenames so you need a "typename" in front of it. so this should work:

#include <iostream>
#include <type_traits>
using namespace std;

template <int N>
struct int_type {
    using mytype = typename std::conditional<N <= 8, std::uint8_t,
                     typename std::conditional<N <= 16, std::uint16_t,
                       typename std::conditional<N <= 32, std::uint32_t,
                         typename std::conditional<N <= 64, std::uint64_t,
                           std::uintmax_t
                         >::type
                       >::type
                     >::type
                   >::type;
};

answered Dec 14 '14 at 15:57

PeterT

7,981
1
26
34

1

`std::conditional_t` is not a typedef, but an alias template, it adds `typename` on its own in the definition – Piotr Skotnicki Dec 14 '14 at 15:58
@PiotrS. I mean that I wrote `typedef std::conditional<...> type;` and it showed a different error – PeterT Dec 14 '14 at 16:00
1

remove the first part of your answer then, nonetheless, the error doesn't indicate compiler's inability to resolve a dependent name, rather, missing support for aliasing – Piotr Skotnicki Dec 14 '14 at 16:01
@vsoftco I'm pretty sure they are dependent types, which is why the `conditional_t` alias uses `using conditional_t = typename conditional::type;`. You are correct that this is not the reason why OPs compilation failed and it's not really relevant to his question but those are dependent types. – PeterT Dec 14 '14 at 16:26
@PeterT ok, you are right, they are dependent, removed my comment, what I meant is that they belong to the current instantiation and do not need the `typename` qualifier, as the compiler is not confused between a type and an eventual variable declaration. See e.g. http://en.cppreference.com/w/cpp/language/dependent_name near the bottom, where some examples are given about the usage of `typename`. – vsoftco Dec 14 '14 at 16:29

'using type' in C++ causes several errors

3 Answers3