Tham số không được sử dụng trong c ++ 11

Trong c ++ 03 trở về trước để tắt cảnh báo trình biên dịch về tham số không sử dụng, tôi thường sử dụng mã như vậy:

#define UNUSED(expr) do { (void)(expr); } while (0)

Ví dụ

int main(int argc, char *argv[])
{
    UNUSED(argc);
    UNUSED(argv);

    return 0;
}

Nhưng macro không phải là phương pháp hay nhất cho c ++, vì vậy. Có giải pháp nào tốt hơn xuất hiện với tiêu chuẩn c ++ 11 không? Ý tôi là tôi có thể loại bỏ macro không?

Cảm ơn vì tất cả!

Tôi đã sử dụng một hàm với phần thân trống cho mục đích đó:

template <typename T>
void ignore(T &&)
{ }

void f(int a, int b)
{
  ignore(a);
  ignore(b);
  return;
}

Tôi mong đợi bất kỳ trình biên dịch nghiêm túc nào sẽ tối ưu hóa lệnh gọi hàm và nó làm im lặng các cảnh báo cho tôi.

Bạn chỉ có thể bỏ qua tên tham số:

int main(int, char *[])
{

    return 0;
}

Và trong trường hợp của main, bạn thậm chí có thể bỏ qua các thông số hoàn toàn:

int main()
{
    // no return implies return 0;
}

Xem "§ 3.6 Bắt đầu và Kết thúc" trong Tiêu chuẩn C ++ 11.

Có <tuple>trong C ++ 11 , bao gồm std::ignoređối tượng sẵn sàng sử dụng , cho phép chúng tôi viết (rất có thể mà không áp đặt chi phí thời gian chạy):

void f(int x)
{
    std::ignore = x;
}

Để "vô hiệu hóa" cảnh báo này, cách tốt nhất là tránh viết đối số, chỉ viết kiểu.

void function( int, int )
{
}

hoặc nếu bạn thích, hãy bình luận nó ra:

void function( int /*a*/, int /*b*/ )
{
}

Bạn có thể kết hợp các đối số có tên và không có tên:

void function( int a, int /*b*/ )
{
}

Với C ++ 17, bạn có mã định nghĩa thuộc tính [[could_unused]], như:

void function( [[maybe_unused]] int a, [[maybe_unused]] int b )
{
}

Không có gì tương đương, không.

Vì vậy, bạn bị mắc kẹt với các tùy chọn cũ giống nhau. Bạn có hài lòng khi loại bỏ hoàn toàn các tên trong danh sách tham số không?

int main(int, char**)

mainTất nhiên, trong trường hợp cụ thể , bạn có thể chỉ cần bỏ qua các tham số:

int main()

Ngoài ra còn có các thủ thuật triển khai cụ thể điển hình, chẳng hạn như GCC __attribute__((unused)).

Macro có thể không lý tưởng, nhưng chúng hoạt động tốt cho mục đích cụ thể này. Tôi muốn nói rằng hãy sử dụng macro.

Bạn có gì để chống lại cách cũ và tiêu chuẩn?

void f(int a, int b)
{
  (void)a;
  (void)b;
  return;
}

Không có gì mới.

Điều tốt nhất đối với tôi là nhận xét tên tham số trong việc triển khai. Bằng cách đó, bạn thoát khỏi cảnh báo, nhưng vẫn giữ lại một số khái niệm về tham số là gì (vì tên có sẵn).

Macro của bạn (và mọi cách tiếp cận truyền thành khoảng trống khác) có nhược điểm là bạn thực sự có thể sử dụng tham số sau khi sử dụng macro. Điều này có thể làm cho mã khó bảo trì hơn.

Tiêu đề Boost <boost/core/ignore_unused.hpp>(Boost> = 1.56) xác định mẫu hàm cho mục đích này boost::ignore_unused().

int fun(int foo, int bar)
{
  boost::ignore_unused(bar);
#ifdef ENABLE_DEBUG_OUTPUT
  if (foo < bar)
    std::cerr << "warning! foo < bar";
#endif

  return foo + 2;
}

PS C ++ 17 có [[maybe_unused]]thuộc tính để loại bỏ cảnh báo trên các thực thể không sử dụng.

Tôi thực sự thích sử dụng macro cho việc này, vì nó cho phép bạn kiểm soát tốt hơn khi bạn có các bản dựng gỡ lỗi khác nhau (ví dụ: nếu bạn muốn xây dựng với các xác nhận được bật):

#if defined(ENABLE_ASSERTS)
  #define MY_ASSERT(x) assert(x)
#else
  #define MY_ASSERT(x)
#end

#define MY_UNUSED(x)

#if defined(ENABLE_ASSERTS)
  #define MY_USED_FOR_ASSERTS(x) x
#else
  #define MY_USED_FOR_ASSERTS(x) MY_UNUSED(x)
#end

và sau đó sử dụng nó như:

int myFunc(int myInt, float MY_USED_FOR_ASSERTS(myFloat), char MY_UNUSED(myChar))
{
  MY_ASSERT(myChar < 12.0f);
  return myInt;
}

Tôi có cách triển khai của riêng mình cho các phân đoạn mã quan trọng về thời gian. Tôi đã nghiên cứu một đoạn mã quan trọng về thời gian để làm chậm và nhận thấy việc triển khai này tiêu tốn khoảng 2% so với thời gian mã quan trọng mà tôi đã được tối ưu hóa:

#define UTILITY_UNUSED(exp) (void)(exp)
#define UTILITY_UNUSED2(e0, e1) UTILITY_UNUSED(e0); UTILITY_UNUSED(e1)
#define ASSERT_EQ(v1, v2) { UTILITY_UNUSED2(v1, v2); } (void)0

Mã quan trọng về thời gian đã sử dụng các ASSERT*định nghĩa cho mục đích gỡ lỗi, nhưng trong bản phát hành rõ ràng nó đã bị loại bỏ, nhưng ... Có vẻ như mã này tạo ra mã nhanh hơn một chút trong Visual Studio 2015 Update 3:

#define UTILITY_UNUSED(exp) (void)(false ? (false ? ((void)(exp)) : (void)0) : (void)0)
#define UTILITY_UNUSED2(e0, e1) (void)(false ? (false ? ((void)(e0), (void)(e1)) : (void)0) : (void)0)

Lý do là trong false ?biểu thức kép . Bằng cách nào đó, nó tạo ra mã nhanh hơn một chút khi được phát hành với tối ưu hóa tối đa.

Tôi không biết tại sao điều này nhanh hơn (có vẻ như một lỗi trong tối ưu hóa trình biên dịch), nhưng ít nhất nó là một giải pháp tốt hơn cho trường hợp mã đó.

Lưu ý : Điều quan trọng nhất ở đây là một đoạn mã quan trọng về thời gian sẽ bị chậm lại mà không có các xác nhận ở trên hoặc các macro không sử dụng được phát hành. Nói cách khác, false ?biểu thức kép giúp tối ưu hóa mã một cách đáng ngạc nhiên.

windows.h xác định UNREFERENCED_PARAMETER :

#define UNREFERENCED_PARAMETER(P) {(P) = (P);}

Vì vậy, bạn có thể làm như thế này:

#include <windows.h>
#include <stdio.h>
int main(int argc, char **argv) {
  UNREFERENCED_PARAMETER(argc);
  puts(argv[1]);
  return 0;
}

Hoặc bên ngoài Windows:

#include <stdio.h>
#define UNREFERENCED_PARAMETER(P) {(P) = (P);}
int main(int argc, char **argv) {
  UNREFERENCED_PARAMETER(argc);
  puts(argv[1]);
  return 0;
}