How to write a traits conversion to add 'const' to type*

Question

Is it possible to have a traits in order to convert, let's say, char* to const char* in order to use it further to call functions having const char* parameters using a char* variable?

I have this (the context is large, I've simplified, sorry for the ugly code):

#include <iostream>
using namespace std;
#include <stdio.h>
#include <string.h>
#include <typeinfo>

template<typename T, typename U, std::enable_if_t<std::is_same<T, U>::value, int> = 0>
T convert_type(U _in)
{
    return _in;
}

template<typename T, typename U, std::enable_if_t<std::is_same<T, std::add_lvalue_reference_t<U>>::value, int> = 0>
T& convert_type(U& _in)
{
    return _in;
}

template<typename T, typename U, std::enable_if_t<std::is_same<T, std::add_lvalue_reference_t<std::add_const_t<U>>>::value, int> = 0>
T& convert_type(U& _in)
{
    return _in;
}

template<typename T, typename U, std::enable_if_t<std::is_same<T, std::add_pointer_t<U>>::value, int> = 0>
T convert_type(U& _in)
{
    return std::addressof(_in);
}

int main() {

    char* c = new char[sizeof "test"];
    strcpy(c, "test");

    const char * cc = convert_type<const char *, char *>(c); // here not compilable yet due to lack of the right convert_type specialization

    cout << c;

    delete[] c;
    return 0;
}

Just to clarify, I embed SpiderMonkey to script Illustrator API. This made me write pretty complicated code, but I have checked and I know the conversion traits above are in use for various function calls. I've added them here just to see the approach and to clarify the need of adding another that recognizes a type and returns the needed type. All your comments are correct generally, but not in my context. I might have a convoluted code, but I have simplified it as much as I could.

sample code here

As far as it concerns me, the question is not yet answered and I couldn't find a solution. I put the question this way: how to write a traits method to match char* against const char*, which is char const*, actually, when I check in msvc with typeid a type or variable declared as const char*?

Answer 1

Is it possible to have a traits in order to convert, let's say, char* to const char* in order to use it further to call functions having const char* parameters using a char* variable?

As pointed out in the comments, a traits conversion isn't needed at all, since a char* pointer can be used equally as a const char* pointer at any time, since the conversion is implicit (same for any other type than char).

---

Note that the line in your main() function

char * c = "test";

isn't valid c++ syntax. "test" actually is a const char [5] type and you can't assign that to other than a const char* pointer legally.
At least any attempt to write a value to that pointer will be undefined behavior.

Most c++11 compliant compilers will issue a warning on that statement.

---

As for your edited example now

char* c = new char[sizeof "test"];
strcpy(c, "test");

//const char * cc = convert_type<const char *, char *>(c);

there's no need for using the convert_type() traits function, you can simply write (as also mentioned in the comments):

const char * cc = c;

Answer 2

Just use assignment:

const char* cc = c;

(with the caveat that char* c = "test" is ill-formed)

To be more explicit, which is never a bad thing, you can use one of the standard C++ casts:

auto cc = static_cast<const char*>(c);

---

Your first three convert_type() overloads are basically useless - all of them can be trivially substituted by simply using =. And = actually handles more cases than your convert_type() too.

The fourth overload should be substituted in favor of just & (or directly using std::addressof), there's really no need to hide that you're taking the address. Certainly T* x = &y is a lot easier to understand the meaning of than T* x = convert_type<T*>(y).

Answer 3

(To 'defend' OP: yes, I also thought of simply adding const, since const const T is the same as const T, but, on the other hand, I can think of situations, where you have to pass a type trait that does nothing else but this.) How about:

// ordinary way w/o type aliases
template<typename T>
struct const_qualify
{
    typedef const T type;
};

// do this if you have type aliases
template<typename T>
using const_qualify_t = const T;

Note that, if you just want to compare types, we have now remove_const<> / remove_cv<>: http://en.cppreference.com/w/cpp/types/remove_cv

EDIT: actually, we also have std::add_const<>.

Answer 4

Eventually, I've made it, using this post:

template<typename T> struct remove_all_const : std::remove_const<T> {};

template<typename T> struct remove_all_const<T*> {
    typedef typename remove_all_const<T>::type *type;
};

template<typename T> struct remove_all_const<T * const> {
    typedef typename remove_all_const<T>::type *type;
};


template<typename T, typename U, std::enable_if_t<std::is_same<typename remove_all_const<T>::type, typename remove_all_const<U>::type>::value, int> = 0>
T convert_type(U& _in)
{
    return _in;
}

A big Thank! to that post solver!