¿Por qué es std :: string :: append () menos poderoso que std :: string :: operator + ()?

Me di cuenta que

std::string str; str += 'b'; // works str.append('b'); // does not work str.append(1, 'b'); // works, but not as nice as the previous 

¿Hay alguna razón por la que el método de append no admita que se append un solo carácter? Asumí que el operator+= es en realidad una envoltura para el método de append , pero este no parece ser el caso.

Es interesante notar que la forma de append aquí;

 string& append( size_type count, CharT ch ); 

Refleja el constructor teniendo entrada similar .

 basic_string( size_type count, CharT ch, const Allocator& alloc = Allocator() ); 

Y algunos otros métodos que tienen un count con un carácter, como resize( size_type count, CharT ch ); .

La clase de cadena es grande y es posible que el caso de uso particular (y la sobrecarga) para str.append('b'); No se consideró, o las alternativas se consideraron suficientes.

Simplemente, la introducción de una sobrecarga única para esto podría generar ambigüedad si las integrales int y char corresponden (en algunas plataformas puede ser el caso).

Hay varias alternativas para agregar un solo carácter.

  • La adición de una cadena que contiene un solo carácter puede hacerse str.append("b"); . Si bien esto no es exactamente lo mismo, tiene el mismo efecto.
  • Como se mencionó hay operator+=
  • También hay push_back() , que es consistente con otros contenedores estándar

El punto es que probablemente nunca se consideró como un caso de uso (o un caso de uso lo suficientemente fuerte), por lo tanto, no se agregó una sobrecarga / firma adecuada para append para atenderlo.


Se podrían debatir diseños alternativos, pero dada la madurez de la norma y esta clase, es poco probable que se cambien pronto, ya que podría romper muchos códigos.

También se podrían considerar firmas alternativas para append ; una posible solución podría haber sido revertir el orden del count y el char (posiblemente agregando un valor predeterminado);

 string& append(CharT ch, size_type count = 1); 

Otro, como se describe en algunas de las críticas de basic_string es eliminar el basic_string , hay muchos métodos para lograr lo que hace.

Me imagino que el operator+=() está destinado a manejar todos los casos simples (tomando solo un parámetro), mientras que append() es para cosas que requieren más de un parámetro.

En realidad, estoy más sorprendido de la existencia del append( const basic_string& str ) de un solo parámetro append( const basic_string& str ) y del append( const CharT* s ) que de la ausencia del append( CharT c ) .

También tenga en cuenta mi comentario anterior: char es solo un tipo entero. Agregar una sobrecarga de tipo entero, parámetro único a append() – o el constructor (que, por diseño, ya tiene varias sobrecargas de tipo entero) podría generar ambigüedad.

A menos que alguien encuentre alguna razón escrita, o algunos miembros del comité publiquen aquí lo que recuerden sobre la discusión, probablemente sea una explicación tan buena como cualquiera.