Difference Between Structures and Classes in C++

The only difference between classand structis the visibility of its members, with members being structpublic by default while members of classare private by default.

Ignoring that difference, both constructs are the same:

Both can be used in inheritance

struct A {};
class B {};

struct C : public A, public B {};
class D : public A, public B {};

This implies that they can also both have virtual functions, pure virtual functions, override functions and use any level of inheritance.

Both can have public, protected and private members

struct S
{
    int publico; // miembro publico.
protected:
    int protegido; // miembro protegido.
private:
    int privado; // miembro privado.
};

class C
{
    int privado; // miembro privado.
protected:
    int protegido; // miembro protegido.
public:
    int publico; // miembro publico.
};

Both auto-generate the special functions

In both cases, if not explicitly defined, it will be created automatically:

• Default constructor.
• Copy Builder.
• movement builder.
• Copy-assign operator.
• Destroyer.

Both can be pre-declared

struct S; // pre-declaracion de S
class C; // pre-declaracion de C

struct S { int i; }; // declaracion de S
class C { int i; }; // declaracion de C

I wanted to mention this point because it is possible to pre-declare an object as classand then declare it as struct(and vice versa); most compilers accept this although they usually display an alarm.

Both have the same structure in memory

A class and a struct with the same members in the same order will occupy the same amount of memory and have the same padding between members.

struct S { char c; short s; int i; float f; double d; };
class C { char c; short s; int i; float f; double d; };

static_assert(sizeof(S) == sizeof(C)); // Verdadero!

In C++ structand classare practically the same, with the only difference that in one structthe default members are public and in one classthey are private by default.

A structcan contain the same as a class, methods, constructors, destructors, inheritance.

Apart from what was mentioned in other answers on the subject of visibility (a topic on which I am not going to comment because it is already well documented in other answers) there is a second difference between the use of structand classand it is in the case of template:

classcan be used to declare types for a template, while structnot:

// ok
template<class T>
void func1(T t)
{ std::cout << t << '\n'; }

// ok
template<typename T>
void func2(T t)
{ std::cout << t << '\n'; }


// error
template<struct T>
void func3(T t)
{ std::cout << t << '\n'; }