Tại sao toán tử bậc ba được sử dụng để xác định 1 và 0 trong macro?

Tôi đang sử dụng SDK cho một dự án nhúng. Trong mã nguồn này, tôi tìm thấy một số mã mà ít nhất tôi thấy đặc biệt. Ở nhiều nơi trong SDK có mã nguồn ở định dạng này:

#define ATCI_IS_LOWER( alpha_char )  ( ( (alpha_char >= ATCI_char_a) && (alpha_char <= ATCI_char_z) ) ? 1 : 0 )

#define ATCI_IS_UPPER( alpha_char )  ( ( (alpha_char >= ATCI_CHAR_A) && (alpha_char <= ATCI_CHAR_Z) ) ? 1 : 0 )

Việc sử dụng toán tử bậc ba ở đây có tạo ra sự khác biệt nào không?

Không

#define FOO (1 > 0)

giống như

#define BAR ( (1 > 0) ? 1 : 0)

?

Tôi đã thử đánh giá nó bằng cách sử dụng

printf("%d", FOO == BAR);

và nhận được kết quả 1, vì vậy có vẻ như chúng bằng nhau. Có lý do gì để viết mã như họ đã làm không?

Bạn đã đúng, trong C nó là tính tế nhị. Cả hai điều kiện bậc ba cụ thể của bạn và (1 > 0) đều thuộc loại int.

Nhưng nó sẽ quan trọng trong C ++, trong một số trường hợp góc gây tò mò (ví dụ như tham số cho các hàm được nạp chồng), vì biểu thức điều kiện bậc ba của bạn là kiểu int, trong khi đó (1 > 0)là kiểu bool.

Tôi đoán rằng tác giả đã đặt một số suy nghĩ vào điều này, với mục đích duy trì khả năng tương thích C ++.

Có những công cụ linting cho rằng kết quả của phép so sánh là boolean và không thể sử dụng trực tiếp trong số học.

Không phải để đặt tên hay chỉ bất kỳ ngón tay nào, nhưng PC-lint là một công cụ kẻ viền như vậy .

Tôi không nói rằng họ đúng, nhưng đó là một lời giải thích khả thi cho việc tại sao mã được viết như vậy.

Đôi khi bạn sẽ thấy điều này trong mã rất cũ , từ trước khi có tiêu chuẩn C để viết chính tả (x > y)đánh giá thành số 1 hoặc 0; một số CPU muốn đánh giá đó là −1 hoặc 0, và một số trình biên dịch rất cũ có thể đã làm theo, vì vậy một số lập trình viên cảm thấy họ cần thêm sự phòng thủ.

Đôi khi bạn cũng sẽ thấy điều này vì các biểu thức tương tự không nhất thiết phải đánh giá thành số 1 hoặc 0. Ví dụ: trong

#define GRENFELZ_P(flags) (((flags) & F_DO_GRENFELZ) ? 1 : 0)

&biểu thức bên trong đánh giá bằng 0 hoặc giá trị số F_DO_GRENFELZ, có thể không phải là 1, vì vậy các ? 1 : 0phục vụ để chuẩn hóa nó. Cá nhân tôi nghĩ sẽ rõ ràng hơn khi viết điều đó là

#define GRENFELZ_P(flags) (((flags) & F_DO_GRENFELZ) != 0)

nhưng những người hợp lý có thể không đồng ý. Nếu bạn có một loạt các biểu thức này liên tiếp, thử nghiệm các loại biểu thức khác nhau, ai đó có thể đã quyết định rằng sẽ dễ bảo trì hơn nếu đặt ? 1 : 0ở cuối tất cả chúng hơn là lo lắng về việc cái nào thực sự cần nó.

Có một lỗi trong mã SDK, và có thể là một con chim mồi khó sửa chữa.

Là một macro, các đối số (alpha_char) có thể là bất kỳ biểu thức nào và phải được đặt trong ngoặc đơn vì các biểu thức như 'A' && 'c' sẽ không kiểm tra được.

#define IS_LOWER( x ) ( ( (x >= 'a') && (x <= 'z') ) ?  1 : 0 )
std::cout << IS_LOWER('A' && 'c');
**1**
std::cout << IS_LOWER('c' && 'A');
**0**

Đây là lý do tại sao người ta phải luôn đặt dấu ngoặc đơn đối số macro trong phần mở rộng.

Vì vậy, trong ví dụ của bạn (nhưng với các tham số), cả hai đều bị nghe lén.

#define FOO(x) (x > 0)
#define BAR(x) ((x > 0) ? 1 : 0)

Chính xác nhất chúng sẽ được thay thế bằng

#define BIM(x) ((x) > 0)

@CiaPan Có một điểm tuyệt vời trong nhận xét sau đó là việc sử dụng một tham số nhiều lần dẫn đến kết quả không xác định được. Ví dụ

#define IS_LOWER( x ) (((x) >= 'a') && ((x) <= 'z'))
char ch = 'y';
std::cout << IS_LOWER(ch++);
**1** 
**BUT ch is now '{'**

Trong C nó không quan trọng. Biểu thức boolean trong C có kiểu intvà giá trị là 0hoặc 1, vì vậy

ConditionalExpr ? 1 : 0

không có hiệu lực.

Trong C ++, nó thực sự là một phép ép kiểu int, vì các biểu thức điều kiện trong C ++ có kiểu bool.

#include <stdio.h>
#include <stdbool.h>

#ifndef __cplusplus

#define print_type(X) _Generic(X, int: puts("int"), bool: puts("bool") );

#else
template<class T>
int print_type(T const& x);
template<> int print_type<>(int const& x) { return puts("int"); }
template<> int print_type<>(bool const& x) { return puts("bool"); }


#endif

int main()
{
    print_type(1);
    print_type(1 > 0);
    print_type(1 > 0 ? 1 : 0);

/*c++ output:
  int 
  int 
  int

  cc output:
  int
  bool
  int
*/

}

Cũng có thể không có hiệu ứng nào được dự định, và tác giả chỉ nghĩ rằng nó làm cho mã rõ ràng hơn.

Một lời giải thích đơn giản là một số người không hiểu rằng một điều kiện sẽ trả về cùng một giá trị trong C, hoặc họ nghĩ rằng viết sẽ sạch hơn ((a>b)?1:0).

Điều đó giải thích tại sao một số cũng sử dụng các cấu trúc tương tự trong các ngôn ngữ có boolean thích hợp, trong cú pháp C sẽ là như vậy (a>b)?true:false).

Điều này cũng giải thích tại sao bạn không nên thay đổi macro này một cách không cần thiết.

Có thể, là một phần mềm nhúng, sẽ cung cấp một số manh mối. Có thể có nhiều macro được viết bằng cách sử dụng kiểu này, để dễ dàng gợi ý rằng các dòng ACTI sử dụng logic trực tiếp hơn là logic ngược.