calling version of is_const<> but for variables instead of types, in one line

Question

Hi I am learning c++ and I read about type traits such as is_const. is_const can be called in one line like,

cout << is_const<double>::value << endl;

I made my own version of is_const but to test if a variable is const, and it can be used like this,

#include<iostream>
using namespace std;

template<typename T>
  struct check_const {
    check_const(const T *x): val(std::true_type{})
    { }
    check_const(T *x) : val(std::false_type{})
    { }
    bool val;
};

int main() 
{
   const double pi= 3.14;
   check_const<double> r(&pi);
   cout <<  r.val << endl;    // returns 1
   double x= 2.7;
   check_const<double> s(&x);
   cout << s.val << endl;    // returns 0
   return(0);
}

I would like to call check_const in one line as well, but the compiler keeps giving me errors like

"typename not allowed"

when I try calling it like

cout << check_const<double> t(&pi)::val << endl;

How can I change check_const, so it can be called in one line?

please dont paraphrase errors "like "typename not allowed"", but include error message in the question — 463035818_is_not_an_ai, Mar 21 '20 at 19:49
you dont need type traits to check if a variable is const or not. All you need is a function iwth a const and a non-const overload. Actually you already use that in your code — 463035818_is_not_an_ai, Mar 21 '20 at 19:52
@idclev I realize it is not useful, I'm just doing it for fun — betafractal, Mar 21 '20 at 19:53
@rafix07 that worked! Is there a name for that, where can i read why that works? — betafractal, Mar 21 '20 at 19:54
@Sam I do not know declaretype(), but I will read about it, how would you use it here though? — betafractal, Mar 21 '20 at 19:54
@betafractal Your code works perfectly. All you needed was a semicolon on line 18 — Aniket Chowdhury, Mar 21 '20 at 19:55
I see now if I call it without assigning to an object, it works. Thank you! I will read about decltype() and try to implement with that @Sam. — betafractal, Mar 21 '20 at 20:08

walnut · Accepted Answer · 2020-03-21T21:01:15.040

You are just using a slightly wrong syntax here:

cout << check_const<double> t(&pi)::val << endl;

Instead use

cout << check_const<double>(&pi).val << endl;

check_const<double> t(&pi) is the syntax for the definition of a named variable, but you cannot have declarations/definitions inside an expression.

check_const<double>(&pi) is the syntax to create an unnamed temporary, which can be done in expressions.

Then you need . instead of ::, because val is a non-static member of check_const.

Starting with C++17 you could also write:

cout << check_const(&pi).val << endl;

and have the template argument be deduced for you.

All of this can be simplified though, as you aren't really using the class. You can just use the constructors as free functions:

template<typename T>
constexpr bool check_const(const T *x) noexcept { return true; }

template<typename T>
constexpr bool check_const(T *x) noexcept { return false; }

(The constexpr makes it possible to use the functions in constant expressions, but is otherwise not required. Similarly noexcept is just an indicator that the function doesn't throw exceptions, but is otherwise not required.)

This can be used more easily as

cout << check_const(&pi) << endl;

Also, instead of pointers, use references:

template<typename T>
constexpr bool check_const(const T &x) noexcept { return true; }

template<typename T>
constexpr bool check_const(T &x) noexcept { return false; }

and you can write

cout << check_const(pi) << endl;

calling version of is_const<> but for variables instead of types, in one line

1 Answers1