Respuesta.

Sobrecarga de funciones: es la capacidad de crear varias funciones con el mismo nombre pero con diferentes argumentos. Esto se utiliza para mejorar la legibilidad y proporcionar una interfaz intuitiva.

Sobrecarga de operadores: es la capacidad de definir cómo los operadores estándar funcionan con tipos de datos de usuario (clases o estructuras).

Restricciones de la sobrecarga de operadores:

• No todos los operadores se pueden sobresalir (.:, .*, ::, sizeof, ?: y otros).
• El operador debe ser o una función miembro o una función amiga.
• No se puede redefinir la semántica para crear una nueva sintaxis completamente nueva.

Ejemplo de sobrecarga del operador "+":

class Vector2D {
public:
    float x, y;
    Vector2D(float _x, float _y): x(_x), y(_y) {}
    Vector2D operator+(const Vector2D& rhs) const {
        return Vector2D(x + rhs.x, y + rhs.y);
    }
};

Pregunta capciosa.

¿Está permitido sobrecargar el operador coma (,) en C++ y, de ser así, para qué se podría usar?

Respuesta:
Sí, se puede sobrecargar el operador coma para clases de usuario.
Sin embargo, la sobrecarga del operador coma debe realizarse solo si hay un sentido claro, ya que esto puede confundir al lector del código y llevar a consecuencias inesperadas.

struct Logger {
    Logger& operator,(const std::string& msg) {
        std::cout << msg;
        return *this;
    }
};

Ejemplos de errores reales debido a la falta de conocimiento sobre los matices del tema.

---

Historia
En el contexto de una biblioteca matemática, se sobrecargó el operador == para comparar objetos, pero se olvidó de sobrecargar el operador <. Esto llevó a errores de compilación al intentar utilizar contenedores STL que requieren operadoras de comparación, p. ej. std::set, std::map.

---

Historia
Un desarrollador sobrecargó el operador + para la clase Matrix, pero en lugar de devolver un nuevo objeto siempre modificaba el operando izquierdo. El resultado fueron efectos secundarios inesperados y una violación del principio de "pureza" de las operaciones.

---

Historia
Al sobrecargar una función con diferentes tipos de argumentos no se tuvo en cuenta el calificador const:

void foo(SomeClass&);
void foo(const SomeClass&);

Esto llevó a ambigüedad en la llamada a la función y errores de compilación al pasar objetos temporales.