La plaga Tux

Desde hace mucho tiempo me he preguntado acerca de las diferencias y similitudes a la hora de usar clases y estructuras en C++, pero hasta ahora no me había parado a buscar información sobre ello. La única diferencia entre las structs y las classes es que los miembros de las estructuras son public por defecto, y los miembros de las clases son private. Suele haber una idea equivocada de que una estructura de C++ es lo mismo que una estructura de C, y que por lo tanto hay muchas diferentes entre las estructuras y clases, como que las estructuras no tienen constructores, métodos miembro o herencia. Sin embargo, como ya he dicho solo se diferencian por el ámbito de las variables miembro.

Las estructuras de C

Las estructuras de C son bestias bastante simples. Solo contienen tipos de datos primitivos como miembros, y todos son visibles a cualquier cosa que pueda acceder a la definición de la estructura. No tienen métodos, constructores o destructores, y no incorporan un mecanismo de herencia.

Las estructuras de C++

Sin embargo, las estructuras de C++ no son lo mismo que las de C. Es cierto que C++ es totalmente compatible con las declaraciones de estructuras de C; cualquier definición legal de una estructura en C compilará y definirá exactamente lo mismo que se hace en C. Pero en C++, las estructuras pueden hacer mucho más. De hecho, las estructuras de C++ son exactamente lo mismo que las clases, en todo menos en un aspecto.  Si declaramos miembros en una estructura de C++ de la siguiente forma

struct Foo
{
    int bar;
    char* baz;
};

Los miembros de la estructura tendrán visibilidad pública por defecto, que quiere decir que la siguiente función:

Foo makeFoo()
{
    Foo temp;
    temp.bar = 1;
    temp.baz = "test";
    return temp;
}

Compilará bien. Sin embargo, si por el contrario definimos una clase como la sigiente:

class Foo
{
    int bar;
    char* baz;
};

Entonces la función ahora no compilará, debido a que los miembros de la clase son privados por defecto. Para solucionar esta situación puedes declarar dichas variables como públicas:

class Foo
{
public:
    int bar;
    char* baz;
};

Pero … sorpresa, sorpresa, también puedes cambiar la visbilidad de los miembros de la estructura para que sean por ejemplo privados:

struct Foo
{
private:
    int bar;
    char* baz;
};

Por supuesto, establecer la visibilidad de las variables miembro no tiene mucho sentido si no hacemos uso de todo el resto de funcionalidades que nos proporcionan las clases: funciones miembro, constructores, destructores, herencia, etc. Con las estructuras de C++ se puede decir lo mismo. Prueba lo siguiente:

#include <iostream>
using namespace std;

struct Example
{
    int a;

    Example(int b);
    void printA();
};

Example::Example(int b)
{
    a = b;
}

void Example::printA()
{
    cout << "a = " << a;
}

Compila bien.

Fuentes de información:

• http://carcino.gen.nz/tech/cpp/struct_vs_class.php