¿Este uso del operador", " se considera de mala forma?

Estoy de acuerdo en que su sintaxis se ve bien como la ha escrito.
Mi principal dificultad con el código es que esperaría que lo siguiente sea el mismo

playlist.queue = song1,song2;
playlist.queue = (song1,song2);  //more of c-style, as @Iuser notes.

Mientras que en realidad son completamente diferentes.

Esto es peligroso porque es demasiado fácil introducir errores de uso en el código. Si a alguien le gusta usar paréntesis para agregar énfasis adicional a las agrupaciones (no es raro), entonces la coma podría convertirse en un verdadero dolor. Para ejemplo,

//lets combine differnt playlists
new_playlist.queue =    song1        //the first playlist
                      ,(song3,song4) //the second playlist //opps, I didn't add song 3!
                      , song5;        //the third 

O

new_playlist.queue = (old_playlist.queue, song6); //opps, I edited my old playlist too!

Incidentemente, te has encontrado con boost.asignar: http://www.boost.org/doc/libs/1_47_0/libs/assign/doc/index.html

¿Ha cambiado la precedencia recientemente?

playlist.queue = song1,song2;

Esto debería analizarse como:

(playlist.queue = song1) , song2;

Su ', ' y '+ = ' son los mismos! Sería una mejor coincidencia semántica si su operador de coma creara una lista temporal, insertara los elementos izquierdo y derecho y devolviera los temporales. Entonces podrías escribirlo así;

playlist.queue = (song1,song2);

Con paréntesis explícitos. Eso le daría a los programadores C una oportunidad de luchar para poder leer el código.

Un pequeño problema es que si el compilador no puede elegir su coma de operador sobrecargada, puede recurrir al uso del operador incorporado.

En contraste, con Boost.Asignar mezclar tipos produce un error de compilación.

#include <boost/assign.hpp>

int main()
{
    int one = 1;
    const char* two = "2";
    list<int> li;
    li = one, two;

    using namespace boost::assign;
    std::list<int> li2;
    li2 += one, two;
}

Esto es probablemente algo que pertenece a los programadores, pero aquí están mis dos centavos.

Si estás hablando de código que tiene un contexto bastante estrecho, donde los usuarios lo usarán en un par de lugares y eso es todo, entonces sobrecargar el operador , probablemente esté bien. Si estás creando un lenguaje específico de dominio que se usa en un dominio en particular y en ningún otro lugar, probablemente esté bien.

El problema viene cuando lo estás sobrecargando por algo que esperas que el usuario utilizar con cierta frecuencia.

Sobrecargar , significa que el lector necesita reinterpretar completamente cómo lee su código. No pueden simplemente mirar una expresión y saber instantáneamente lo que hace. Estás jugando con algunas de las suposiciones más básicas que los programadores de C++ hacen cuando se trata de escanear código.

Haz eso bajo tu propio riesgo.

Tengo curiosidad sobre si debo evitarlo, porque sobre todo el el código debe ser fácilmente comprendido por otros programadores

Si el objetivo es hacer que su código sea fácil de entender para otros programadores de C++, anular operadores para darles un significado que es muy diferente del del C++ estándar no es un buen comienzo. Los lectores no deberían tener que a) entender cómo ha implementado su contenedor y b) recalibrar su comprensión de los operadores estándar solo para ser capaz de dar sentido a su código.

Puedo apreciar el precedente de impulso para este tipo de cosas. Si está bastante seguro de que la mayoría de las personas que leerán su código también estarán familiarizadas con Boost Assign, su propia anulación del operador, podría ser bastante razonable. Aún así, sugeriría seguir la sugerencia de @badzeppelin de usar operator

cout << "Hello world!"`

Es malo en muchos niveles...

Estás anulando list y siguiendostd::list. Un gran no-no. Si desea que su propia clase de lista - que sea con un nombre diferente, no sombra de la biblioteca estándar.

Usar , de esta manera no es legible. El valor devuelto del operador es el operando correcto. Incluso si su código funciona, para un lector externo no será obvio por qué, y es algo malo. El código debe ser legible, no agradable.

No hay nada malo en usar coma operator , usando específicamente. Cualquier operador deja mal gusto, si se explota. En tu código, no veo ningún problema razonable. Solo una sugerencia, me gustaría dar es:

list& operator,(list &add_){  // <--- pass by reference to avoid copies
  *this += add_;  // <--- reuse operator +=
  return *this;
}

De esta manera, siempre tienes que editar solo operator +=, si quieres algún cambio en la lógica. Tenga en cuenta que, mi respuesta está en la perspectiva de la legibilidad y el mantenimiento del código en general. No voy a plantear la preocupación sobre la lógica de negocios que utiliza.