Khi nào cần quá tải toán tử dấu phẩy?

Tôi thường xuyên thấy các câu hỏi trên SO về việc nạp chồng toán tử dấu phẩy trong C ++ (chủ yếu không liên quan đến việc nạp chồng, nhưng những thứ như khái niệm về điểm trình tự) và điều đó khiến tôi tự hỏi:

Khi nào bạn nên điền dấu phẩy? Một số ví dụ về công dụng thực tế của nó là gì?

Tôi chỉ không thể nghĩ ra bất kỳ ví dụ nào mà tôi đã thấy hoặc cần đến những thứ như

foo, bar;

trong mã thế giới thực, vì vậy tôi tò mò không biết khi nào (nếu có) điều này thực sự được sử dụng.

Hãy thay đổi sự nhấn mạnh một chút thành:

Khi nào bạn nên điền dấu phẩy?

Câu trả lời: Không bao giờ.

Ngoại lệ: Nếu bạn đang thực hiện lập trình siêu mẫu, operator, có một vị trí đặc biệt ở cuối danh sách ưu tiên toán tử, có thể hữu ích cho việc xây dựng các SFINAE-Guard, v.v.

Hai cách sử dụng thực tế duy nhất mà tôi đã thấy về quá tải operator,đều có trong Boost :

• Boost.Assign
• Boost.Phoenix - điều cơ bản ở đây là nó cho phép các lambdas Phoenix hỗ trợ nhiều câu lệnh

Tôi đã sử dụng toán tử dấu phẩy để lập chỉ mục các bản đồ có nhiều chỉ số.

enum Place {new_york, washington, ...};

pair<Place, Place> operator , (Place p1, Place p2)
{
    return make_pair(p1, p2);
}


map< pair<Place, Place>, double> distance;

distance[new_york, washington] = 100;

Boost.Assign sử dụng nó để cho phép bạn làm những việc như:

vector<int> v; 
v += 1,2,3,4,5,6,7,8,9;

Và tôi đã thấy nó được sử dụng để hack ngôn ngữ kỳ quặc, tôi sẽ xem nếu tôi có thể tìm thấy một số.

Aha, tôi nhớ một trong những cách sử dụng kỳ quặc đó: thu thập nhiều biểu thức . (Cảnh báo, ma thuật hắc ám.)

Dấu phẩy có một thuộc tính thú vị là nó có thể nhận một tham số kiểu void . Nếu đúng như vậy, thì toán tử dấu phẩy có sẵn sẽ được sử dụng.

Điều này rất hữu ích khi bạn muốn xác định xem một biểu thức có kiểu void:

namespace detail_
{
    template <typename T>
    struct tag
    {
        static T get();
    };

    template <typename T, typename U>
    tag<char(&)[2]> operator,(T, tag<U>);

    template <typename T, typename U>
    tag<U> operator,(tag<T>, tag<U>);
}

#define HAS_VOID_TYPE(expr) \
    (sizeof((::detail_::tag<int>(), \
             (expr), \
             ::detail_::tag<char>).get()) == 1)

Tôi để người đọc tự tìm hiểu xem chuyện gì đang xảy ra. Hãy nhớ rằng các operator,liên kết ở bên phải.

Tương tự như ví dụ Boost.Assign của @ GMan , Blitz ++ nạp chồng toán tử dấu phẩy để cung cấp một cú pháp thuận tiện để làm việc với mảng nhiều chiều. Ví dụ:

Array<double,2> y(4,4);   // A 4x4 array of double
y = 1, 0, 0, 0,
    0, 1, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1;

Trong SOCI - Thư viện truy cập cơ sở dữ liệu C ++, nó được sử dụng để triển khai phần gửi đến của giao diện:

sql << "select name, salary from persons where id = " << id,
       into(name), into(salary);

Từ câu hỏi thường gặp cơ sở :

Hỏi: Toán tử dấu phẩy bị quá tải chỉ là sự xáo trộn, tôi không thích nó.

Vâng, hãy xem xét những điều sau:

"Gửi truy vấn X đến máy chủ Y và đặt kết quả vào biến Z."

Ở trên, dấu "và" đóng vai trò của dấu phẩy. Ngay cả khi nạp chồng toán tử dấu phẩy không phải là một thực hành rất phổ biến trong C ++, một số thư viện làm điều này, đạt được cú pháp ngắn gọn và dễ học. Chúng tôi khá chắc chắn rằng trong SOCI, toán tử dấu phẩy đã bị quá tải với một hiệu ứng tốt.

Tôi sử dụng toán tử dấu phẩy để in đầu ra nhật ký. Nó thực sự rất giống ostream::operator<<nhưng tôi thấy toán tử dấu phẩy thực sự tốt hơn cho nhiệm vụ.

Vì vậy, tôi có:

template <typename T>
MyLogType::operator,(const T& data) { /* do the same thing as with ostream::operator<<*/ }

Nó có những đặc tính tốt

• Toán tử dấu phẩy có mức ưu tiên thấp nhất. Vì vậy, nếu bạn muốn truyền trực tuyến một biểu thức, mọi thứ sẽ không rối tung nếu bạn quên dấu ngoặc đơn. So sánh:

  myLog << "The mask result is: " << x&y; //operator precedence would mess this one up
  myLog, "The result is: ", x&y;
  

  bạn thậm chí có thể trộn các toán tử so sánh bên trong mà không gặp vấn đề gì, ví dụ:

  myLog, "a==b: ", a==b;
  

• Toán tử dấu phẩy là nhỏ. Nó không làm rối mắt việc đọc khi dán nhiều thứ lại với nhau

  myLog, "Coords=", g, ':', s, ':', p;
  

• Nó phù hợp với ý nghĩa của toán tử dấu phẩy, tức là "in cái này" và sau đó "in cái kia".

Một khả năng là Boost Assign thư viện (mặc dù tôi khá chắc chắn rằng một số người sẽ coi việc lạm dụng này hơn là sử dụng tốt).

Boost Spirit có thể làm quá tải toán tử dấu phẩy (nó làm quá tải hầu hết mọi thứ khác ...)

Cùng dòng đó, tôi đã được gửi một yêu cầu kéo github với quá tải toán tử dấu phẩy. Nó trông giống như sau

class Mylogger {
    public:
            template <typename T>
            Mylogger & operator,(const T & val) {
                    std::cout << val;
                    return * this;
            }
 };

 #define  Log(level,args...)  \
    do { Mylogger logv; logv,level, ":", ##args; } while (0)

thì trong mã của tôi, tôi có thể làm:

 Log(2, "INFO: setting variable \", 1, "\"\n");

Ai đó có thể giải thích tại sao đây là một trường hợp sử dụng tốt hay xấu?

Một trong những cách sử dụng thực tế là sử dụng hiệu quả nó với các đối số biến trong macro. Nhân tiện, các đối số biến trước đây là một phần mở rộng trong GCC và bây giờ là một phần của tiêu chuẩn C ++ 11.

Giả sử chúng ta có một class X, thêm đối tượng kiểu Avào nó. I E

class X {
  public: X& operator+= (const A&);
};

Nếu chúng ta muốn thêm 1 hoặc nhiều đối tượng Avào X buffer;thì sao?
Ví dụ,

#define ADD(buffer, ...) buffer += __VA_ARGS__

Macro trên, nếu được sử dụng như:

ADD(buffer, objA1, objA2, objA3);

thì nó sẽ mở rộng thành:

buffer += objA1, objeA2, objA3;

Do đó, đây sẽ là một ví dụ hoàn hảo về việc sử dụng toán tử dấu phẩy, vì các đối số biến mở rộng cùng một.

Vì vậy, để giải quyết điều này, chúng tôi nạp chồng commatoán tử và quấn nó xung quanh +=như bên dưới

  X& X::operator, (const A& a) {  // declared inside `class X`
    *this += a;  // calls `operator+=`
  }

Đây là một ví dụ từ tài liệu OpenCV ( http://docs.opencv.org/modules/core/doc/basic_structures.html#mat ). Toán tử dấu phẩy được sử dụng để khởi tạo cv :: Mat:

// create a 3x3 double-precision identity matrix
Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);