防止使用括号或大括号进行初始化

Question

Given a class C , is it possible to prevent construction using parenthesis (eg forbid C c(1); ) or braces (eg forbid C c{1}; )?

---

I am interested in the question per se, but since it got asked what is my motivation:

I do not like the following behaviours:

#include <array>
struct aggregate{ int x,y; };
int main() {
  aggregate A{1};
  std::array< aggregate, 2 > B{1,2,3};
}

which yields

1. Ax=1 , Ay=0
2. B[0].x=1 , B[0].y=2 , B[1].x=3 , B[1].y=0

The first one is at least kind of reasonable, the second one not at all. I rather would like to have a compile time error for both of them.

My goal is to write a container array similiar to (and as efficient as) std::array which prevents such bad constructions.

To be constructed like:

#include <array>
struct aggregate{ int x,y; };
int main() {
  array< aggregate, 2 > A; // all elements default initialized
  array< aggregate, 2 > B{aggregate{1,2},aggregate{3,4}};
  array< aggregate, 2 > C{{1,2},{3,4}};  // would be nice but not mandatory

  // everything below here should yield compile time errors
  array< aggregate, 2 > D(1,2);
  array< aggregate, 2 > D{1,2};
  array< aggregate, 2 > D({1,2});
  array< aggregate, 2 > D(1,2,3,4);
  array< aggregate, 2 > D{1,2,3,4};
  // etc...

}

---

To further detalize my motivation (since it seems, my question is not going to be answered): I am not so concerned about the class aggregate given above, but about the class array . Thus, it is not an option to remove/add ctors from the class.

So far I have the following code: It prevents nearly all of my unwanted initializations, except that it calls unnecessary often a ctor. So my idea is: In Debug mode I typedef array to the class tmm::array`` in the code below, in Release mode I typedef it to std::array . But the problem arises that . But the problem arises that tmm::array allows constructs which are not allowed for std::array`.

#include <array>
#include <iostream>
#include <type_traits>

template <typename T, typename ...Ts>
inline constexpr bool areT_v = std::conjunction_v<std::is_same<T,Ts>...>;

struct CLASS {
    int x, y;
    CLASS() noexcept { 
        std::cout << "default constructed" << std::endl; 
    }
    CLASS(int x_,int y_) noexcept : x(x_), y(y_) { 
        std::cout << "constructed" << std::endl; 
    }
    CLASS( CLASS const & other ) noexcept : x(other.x), y(other.y) {
        std::cout << "copy constructed" << std::endl; 
    }
};

namespace tmm {
    template< typename T, int rows >
    struct array
    {
        template< typename ... L > constexpr inline
        array( L && ... lst ) noexcept : content{ std::forward< L >( lst ) ... } {
            static_assert( sizeof...(L) == rows || sizeof...(L)==0 );
            static_assert( areT_v<T,L...>, "" );
        }
        array() = default;  // not sure whether I need this one
        T content[rows];
    };
}

int main() {
    #define INIT CLASS{1,2},CLASS{3,4},CLASS{5,6}
    std::array<CLASS,3>tb3b {INIT};  // 3 ctors
    tmm::array<CLASS,3> sb3b {INIT};  // 3 ctors and 3 copy ctors
    
//  std::array<CLASS,3> sp3a (INIT);  // does not compile
    tmm::array<CLASS,3>tp3a (INIT);   // compiles
}

Answer 1

Given a class C , is it possible to prevent construction using parenthesis (eg forbid C c(1); ) or braces (eg forbid C c{1}; )?

To answer your question directly, the object of class C will only be constructible with the constructors you provide. That is, if C does not have a constructor from a single int , it won't be constructible using either C c(1); or C c{1}; syntax.

There are a few caveats, especially given your later explanation. First, if your class C is an aggregate then it follows the standard language rules for initialization (that is, it allows aggregate initialization ). You cannot have an aggregate class and prohibit its aggregate initialization at the same time. The only way around it is to specify the constructors you want to allow, at which point the class is no longer an aggregate:

struct C
{
    int x,y;

    C() : x(0), y(0) {}
    C(int x, int y) : x(x), y(y) {}
};

C a(10); // error - no constructor from a single int

Next, type conversions may still happen as part of initialization. If you also want to prohibit those, you may use deleted constructors or SFINAE . For example:

struct C_no_float
{
    int x,y;

    C_no_float() : x(0), y(0) {}
    C_no_float(int x, int y) : x(x), y(y) {}
    C_no_float(double x, double y) = delete;
};

C_no_float a(10, 20); // ok
C_no_float b(1.0, 2.0); // error - calling a deleted constructor

Note that using deleted functions may still be error-prone since the constructor from int s may still be called as a result of type conversion. In other words, this approach does not guarantee that C_no_float is not constructible from anything but exactly a pair of int s. Using SFINAE allows for stronger restriction on argument types:

struct C_only_int
{
    int x,y;

    C_only_int() : x(0), y(0) {}
    template< typename T, typename = std::enable_if_t<std::is_same_v<T, int>> >
    C_only_int(T x, T y) : x(x), y(y) {}
};

C_only_int a(10, 20); // ok, T is int
C_only_int b(10l, 20l); // error - T would be long,
                        // template argument substitution fails