c++ - 指示调用构造函数的编译时间

Question

我有以下类(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;
}

我如何才能在编译 Ptr() 时知道使用哪个构造函数来创建该对象？我想静态断言，在编译 Ptr() 时使用了构造函数 A(T* d):

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

如果程序员在使用 const ptr 创建类 A 的对象时调用 Ptr()，我想检测编译时间。不允许在使用 const ptr 创建时调用 Foo

我想这样用

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

最简单的 c++17(正如我可以告诉您的那样，无论如何都在使用它来推断模板参数类型)方法是使用用户定义的推导指南和附加标记非类型模板参数:

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]

---

编辑:

满足常量正确性的一点改进:

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]