Cách thành ngữ để phân biệt hai hàm tạo zero-arg

Tôi có một lớp học như thế này:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Thông thường tôi muốn mặc định (không) khởi tạo countsmảng như được hiển thị.

Tuy nhiên, tại các vị trí đã chọn được xác định bằng cách định hình, tôi muốn loại bỏ việc khởi tạo mảng, vì tôi biết mảng sắp bị ghi đè, nhưng trình biên dịch không đủ thông minh để tìm ra nó.

Một cách thành ngữ và hiệu quả để tạo ra một hàm tạo zero-arg "thứ cấp" như vậy là gì?

Hiện tại, tôi đang sử dụng một lớp thẻ uninit_tagđược truyền dưới dạng đối số giả, như vậy:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Sau đó, tôi gọi hàm tạo không có init như event_counts c(uninit_tag{});khi tôi muốn ngăn chặn việc xây dựng.

Tôi mở cho các giải pháp không liên quan đến việc tạo ra một lớp giả, hoặc hiệu quả hơn theo một cách nào đó, v.v.

Giải pháp bạn đã có là chính xác và chính xác là những gì tôi muốn xem nếu tôi đang xem lại mã của bạn. Đó là hiệu quả nhất có thể, rõ ràng và súc tích.

Nếu phần thân của hàm tạo trống, nó có thể được bỏ qua hoặc mặc định:

struct event_counts {
    std::uint64_t counts[MAX_COUNTERS];
    event_counts() = default;
};

Sau đó, khởi tạo mặc định event_counts counts; sẽ counts.countskhông được khởi tạo (khởi tạo mặc định là không có ở đây) và khởi tạo event_counts counts{}; giá trị sẽ có giá trị khởi tạo counts.counts, lấp đầy nó bằng các số không.

Tôi thích giải pháp của bạn. Bạn cũng có thể đã xem xét cấu trúc và biến tĩnh lồng nhau. Ví dụ:

struct event_counts {
    static constexpr struct uninit_tag {} uninit = uninit_tag();

    uint64_t counts[MAX_COUNTS];

    event_counts() : counts{} {}

    explicit event_counts(uninit_tag) {}

    // more stuff

};

Với biến tĩnh, lệnh gọi hàm tạo chưa được khởi tạo có vẻ thuận tiện hơn:

event_counts e(event_counts::uninit);

Tất nhiên bạn có thể giới thiệu một macro để lưu gõ và làm cho nó trở thành một tính năng có hệ thống hơn

#define UNINIT_TAG static constexpr struct uninit_tag {} uninit = uninit_tag();

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Tôi nghĩ rằng một enum là một lựa chọn tốt hơn so với một lớp thẻ hoặc bool. Bạn không cần phải truyền một thể hiện của một cấu trúc và nó rõ ràng từ người gọi mà bạn đang nhận tùy chọn.

struct event_counts {
    enum Init { INIT, NO_INIT };
    uint64_t counts[MAX_COUNTERS];

    event_counts(Init init = INIT) {
        if (init == INIT) {
            std::fill(counts, counts + MAX_COUNTERS, 0);
        }
    }
};

Sau đó, việc tạo các trường hợp trông như thế này:

event_counts e1{};
event_counts e2{event_counts::INIT};
event_counts e3{event_counts::NO_INIT};

Hoặc, để làm cho nó giống với cách tiếp cận lớp thẻ hơn, hãy sử dụng một enum giá trị đơn thay vì lớp thẻ:

struct event_counts {
    enum NoInit { NO_INIT };
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}
    explicit event_counts(NoInit) {}
};

Sau đó, chỉ có hai cách để tạo một thể hiện:

event_counts e1{};
event_counts e2{event_counts::NO_INIT};

Bạn có thể muốn xem xét khởi tạo hai pha cho lớp của mình:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

    void set_zero() {
       std::fill(std::begin(counts), std::end(counts), 0u);
    }
};

Hàm tạo ở trên không khởi tạo mảng thành 0. Để đặt các phần tử của mảng thành 0, bạn phải gọi hàm thành viên set_zero()sau khi xây dựng.

Tôi sẽ làm như thế này:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(bool initCounts) {
        if (initCounts) {
            std::fill(counts, counts + MAX_COUNTERS, 0);
        }
    }
};

Trình biên dịch sẽ đủ thông minh để bỏ qua tất cả các mã khi bạn sử dụng event_counts(false)và bạn có thể nói chính xác ý của bạn thay vì làm cho giao diện lớp của bạn trở nên kỳ lạ.

Tôi sẽ sử dụng một lớp con chỉ để tiết kiệm một chút gõ:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}
    event_counts(uninit_tag) {}
};    

struct event_counts_no_init: event_counts {
    event_counts_no_init(): event_counts(uninit_tag{}) {}
};

Bạn có thể thoát khỏi lớp giả bởi sự thay đổi các tham số của các nhà xây dựng không khởi tạo cho boolhay inthoặc một cái gì đó, vì nó không phải là ghi nhớ nữa.

Bạn cũng có thể trao đổi thừa kế xung quanh và xác định events_count_no_initvới một hàm tạo mặc định như Evg đã đề xuất trong câu trả lời của họ và sau đó phải events_countlà lớp con:

struct event_counts_no_init {
    uint64_t counts[MAX_COUNTERS];
    event_counts_no_init() = default;
};

struct event_counts: event_counts_no_init {
    event_counts(): event_counts_no_init{} {}
};