Bạn có thể sử dụng từ khóa rõ ràng để ngăn việc tự động chuyển đổi các tham số phương thức không?

Question

Tôi biết bạn có thể sử dụng từ khóa C++ 'rõ ràng' cho các nhà xây dựng của các lớp học để ngăn chặn việc chuyển đổi kiểu tự động. Bạn có thể sử dụng lệnh này để ngăn việc chuyển đổi các tham số cho một phương thức lớp không?

Tôi có hai thành viên lớp học, một thành viên tham gia bool dưới dạng tham số, một hàm khác là int không dấu. Khi tôi gọi hàm với một int, trình biên dịch chuyển đổi param thành một bool và được gọi là phương thức sai. Tôi biết cuối cùng tôi sẽ thay thế bool, nhưng bây giờ không muốn phá vỡ các thói quen khác như thói quen mới này được phát triển.

Answer 1

Không, bạn không thể sử dụng rõ ràng, nhưng bạn có thể làm điều này thay vì:

class ClassThatOnlyTakesBoolsAndUIntsAsArguments 
{ 
public: 
    void Method(bool arg1); 
    void Method(unsigned int arg1); 

    // Below just an example showing how to do the same thing with more arguments 
    void MethodWithMoreParms(bool arg1, SomeType& arg2); 
    void MethodWithMoreParms(unsigned int arg1, SomeType& arg2); 

private: 
    template<typename T> 
    void Method(T arg1); 

    // Below just an example showing how to do the same thing with more arguments 
    template<typename T> 
    void MethodWithMoreParms(T arg1, SomeType& arg2); 
}; 

Lặp lại mô hình này cho mọi phương pháp mà mất bool hoặc unsigned int. Không cung cấp triển khai cho phiên bản templatized của phương thức.

Điều này sẽ buộc người dùng luôn gọi một cách rõ ràng phiên bản bool hoặc unsigned int.

Bất kỳ nỗ lực nào để gọi Method với loại khác ngoài bool hoặc unsigned int sẽ không biên dịch được vì thành viên là riêng tư, ngoại trừ tiêu chuẩn cho quy tắc hiển thị, tất nhiên (bạn bè, cuộc gọi nội bộ, v.v.). Nếu một cái gì đó mà có quyền truy cập gọi các phương pháp riêng, bạn sẽ nhận được một lỗi linker.

Answer 2

Trình biên dịch đã cảnh báo "gọi không rõ ràng", điều này sẽ là đủ.

Tôi đã thực hiện phát triển TDD và không nhận ra rằng tôi đã quên triển khai cuộc gọi tương ứng trong đối tượng giả.

Answer 3

Bạn cũng có thể viết phiên bản int gọi lệnh bool.

Answer 4

No. explicit ngăn chuyển đổi tự động giữa các lớp cụ thể, bất kể ngữ cảnh. Và tất nhiên bạn không thể làm điều đó cho các lớp học tích hợp.

Answer 5

bool Là một int được giới hạn ở 0 hoặc 1. Đó là toàn bộ khái niệm trả về 0 ;, nó giống hệt như trả về false (không sử dụng mã này).

Answer 6

Điều gì đó có thể phù hợp với bạn là sử dụng mẫu. Phần sau hiển thị chức năng mẫu foo<>() đang được chuyên biệt cho bool, unsigned int và int. Hàm main() cho biết cách các cuộc gọi được giải quyết. Lưu ý rằng các cuộc gọi sử dụng hằng số int không chỉ định hậu tố loại sẽ giải quyết thành foo<int>(), do đó bạn sẽ gặp lỗi khi gọi foo(1) nếu bạn không chuyên về int. Nếu trường hợp này xảy ra, người gọi sử dụng hằng số nguyên nguyên sẽ phải sử dụng hậu tố "U" để nhận cuộc gọi để giải quyết (đây có thể là hành vi bạn muốn).

Nếu không, bạn sẽ phải chuyên về int và sử dụng "U" hậu tố hoặc đúc nó vào một unsigned int trước khi chuyển lên phiên bản unsigned int (hoặc có thể làm một khẳng định rằng giá trị không phải là tiêu cực, nếu đó là những gì bạn muốn).

#include <stdio.h> 

template <typename T> 
void foo(T); 

template <> 
void foo<bool>(bool x) 
{ 
    printf("foo(bool)\n"); 
} 


template <> 
void foo<unsigned int>(unsigned int x) 
{ 
    printf("foo(unsigned int)\n"); 
} 


template <> 
void foo<int>(int x) 
{ 
    printf("foo(int)\n"); 
} 



int main() 
{ 
    foo(true); 
    foo(false); 
    foo(static_cast<unsigned int>(0)); 
    foo(0U); 
    foo(1U); 
    foo(2U); 
    foo(0); 
    foo(1); 
    foo(2); 
} 

Answer 7

Sau đây là một wrapper rất cơ bản mà có thể được sử dụng để tạo ra một typedef mạnh:

template <typename V, class D> 
class StrongType 
{ 
public: 
    inline explicit StrongType(V const &v) 
    : m_v(v) 
    {} 

    inline operator V() const 
    { 
    return m_v; 
    } 

private: 
    V m_v; // use V as "inner" type 
}; 

class Tag1; 
typedef StrongType<int, Tag1> Tag1Type; 


void b1 (Tag1Type); 

void b2 (int i) 
{ 
    b1 (Tag1Type (i)); 
    b1 (i);    // Error 
} 

Một tính năng tuyệt vời của phương pháp này, là bạn cũng có thể phân biệt giữa các thông số khác nhau với cùng kiểu. Ví dụ: bạn có thể có các thông tin sau:

class WidthTag; 
typedef StrongType<int, WidthTag> Width; 
class HeightTag; 
typedef StrongType<int, HeightTag> Height; 

void foo (Width width, Height height); 

Sẽ rõ ràng đối với khách hàng của 'foo' đối số nào.