Indicate compile time what constructor was called - c++

Question

I have the following class
template<typename T>
class A
{
public:
A(T* d) : ptr(d)
{}
A(const T* d) : ptr(const_cast<T*>(d))
{}
T* Ptr()
{
static_assert(???, "Not allowed when using A(const T* d)");
return ptr;
}
const T* Ptr() const
{
return ptr;
}
private:
T* ptr;
}
How can I achieve that when Ptr() is compiled, I know which constructor was used to create this object? I want to statically assert that when Ptr() is compiled that the consstructor A(T* d) was used:
unsigned char* ptr = new unsigned char[10];
const unsigned char* cptr = new unsigned char[10];
A a(ptr);
A ca(cptr);
a.Ptr(); // Compiles
ca.Ptr(); // Gives compile error
I want to detect compile time if the programmer calls Ptr() when the object of class A was created using a const ptr. Calling Foo when created with const ptr is not allowed
I want to use it like this
void Foo(A<int>& r)
{
....
int* ptr = a.Ptr();
....
}
void Bar(const A<int>& r)
{
...
}
...
A a(ptr);
A ca(cptr);
Bar(a);
Bar(ac);
Foo(a);
Foo(ac);// Gives compile error

Answer 1

The simplest c++17 (as I can tell you are using it anyway to deduce template argument type) approach is to use user defined deduction guides and additional tagging non-type template parameter:
enum Tag { //
NonConstTag, // Additional tag enum
ConstTag //
}; //
template<typename T, Tag TT>
// ^^^^^^
// Additional non-type template parameter to provide
// different type of A in case of calling const parameter
// constructor
class A
{
public:
A(T* d) : ptr(d)
{}
A(const T* d) : ptr(const_cast<T*>(d))
{}
T* Ptr()
{
static_assert(TT == NonConstTag, "Not allowed when using A(const T* d)");
return ptr;
}
const T* Ptr() const
{
return ptr;
}
private:
T* ptr;
};
template<typename T> //
A(T* d) -> A<T, NonConstTag>; //
// Deduction guides
template<typename T> //
A(const T* d) -> A<T, ConstTag>; //
int main() {
unsigned char* ptr = new unsigned char[10];
const unsigned char* cptr = new unsigned char[10];
A a(ptr);
A ca(cptr);
a.Ptr(); // Compiles
//ca.Ptr(); // Gives compile error
}
[live demo]
Edit:
A little improvement to satisfy const correctness:
enum Tag {
NonConstTag,
ConstTag
};
template<typename T, Tag TT>
class A
{
public:
A(T* d) : ptr(d), cptr(d)
{}
A(const T* d) : ptr(nullptr), cptr(d)
{}
T* Ptr()
{
static_assert(TT == NonConstTag, "Not allowed when using A(const T* d)");
return ptr;
}
const T* Ptr() const
{
return cptr;
}
private:
T* ptr;
const T* cptr;
};
template<typename T>
A(T* d) -> A<T, NonConstTag>;
template<typename T>
A(const T* d) -> A<T, ConstTag>;
int main() {
unsigned char* ptr = new unsigned char[10];
const unsigned char* cptr = new unsigned char[10];
A a(ptr);
A ca(cptr);
a.Ptr(); // Compiles
//ca.Ptr(); // Gives compile error
}
[live demo]

Answer 2

If you have an IDE it may allow you to jump to the declaration that corresponds to the call. (YouCompleteMe does this in Vim with :YcmCompleter GoTo; I believe Visual Studio has F12 or Alt-F12, if I remember correctly).
Besides that, if you want to detect it runtime, set a flag:
template <typename T> class A {
public:
A(T *) {}
A(const T *) : used_const_arg_ctor(true) {}
private:
bool used_const_arg_ctor = false;
void Foo() {
if (used_const_arg_ctor) {
}
}
};
To actually static assert it, make it a constexpr type:
#include <boost/asio.hpp>
template <typename T> class A {
public:
constexpr A(T *) {}
constexpr A(const T *) : used_const_arg_ctor(true) {}
constexpr bool Foo() const {
return used_const_arg_ctor;
}
private:
bool used_const_arg_ctor = false;
};
int main() {
int const i = 42;
constexpr A<int> a(&i);
static_assert(a.Foo(), "is constructed from const pointer");
}
This has limited usefulness. I'd suggest, instead, to have T reflect constness:
template <typename T> class A {
public:
A(T*d) : _v(d) {}
constexpr bool IsConst() const { return std::is_const<T>::value; }
private:
T* _v;
};