What is the best method to access a class member?

Question

What is the best method to access a class member for speed and organization?

class cMinhaClasse
{
public:
    void Funcao(int r);
};

int main()
{
    // Método 1 - Acessando classe por ponteiro
    cMinhaClasse *mClasse = new cMinhaClasse();

    if(!mClasse)
    {
        MessageBoxA(NULL, "Erro ao criar o ponteiro para classe     MinhaClasse", "Fatal erro!", NULL); 
    }
    else
    {
        mClasse->Funcao(50);
    }

    // Método 2 - Acessando diretamente
    cMinhaClasse::Funcao(50);

    // Método 3 - Acessando por objeto
    cMinhaClasse MinhaClasse;
    MinhaClasse.Funcao(50);
}

Answer 1

Each one does something different so the comparison gets complicated. The best is the one that meets you in the specific need of that moment.

cMinhaClasse *mClasse = new cMinhaClasse();

Here is creating an object in heap and assigning a pointer to this object in the variable. Track time can be long and usually you have to manage your destruction if the class no longer does. You can use a smart pointer to do this, but it was not used in this case. If you do not release this memory there will be leakage. It should only be used if needed, which doesn’t seem to be the case here, but this example is useless anyway, so it doesn’t count.

cMinhaClasse::Function(50);

Here is calling a static function, does not create an object, if it does not depend on any object can be a good one. Creating an object to do something you didn’t need it doesn’t make sense. It seems to be the case, so I would say that in this restricted example is the best option. But if it changes a little and in real cases it will be quite different, this option may not be feasible.

cMinhaClasse Minhaclasse;

Here is creating the direct object in stack and memory management is automatic, but life time is only while inside the function where the object was created. Again you are creating an object needlessly in what has been described.

Compilers do not execute anything (with exception in C++, but this does not need to be considered for understanding here), they process a text and general execution code.

The running time of these things is in the nanosecond house and not milliseconds.

Of course creating an object is much more time consuming, but if you need it there is no escape. If you don’t need it makes no sense to create. As in link above describes, in stack is faster than in heap, but nothing beats creating nothing.

What gives even performance is to make correct algorithms, understand the entire functioning of the code in every detail. Knowing one detail and not knowing others, all the implications, how the characteristics interact with each other, will make it difficult to get performance. In fact the search for him in this way is not a good way.

Strange syntax or not is a matter of taste and nothing interferes with organization. For example, for my taste this code is poorly written and strange, but some people do not think.

It matters little if it is namespace or class in single functions.

Answer 2

class Foobar
{
    public:

        Foobar( void ) {};
        virtual ~Foobar( void ) {};

        void xpto( int n ) {};
        static void xyz( int n ) {};
};


int main()
{
    Foobar::xyz(50);  // OK: Acessando método estático da classe, não é necessario uma instancia.

    Foobar::xpto(50); // ERRO: Método não estático, é necessário uma instância.

    Foobar * p = new Foobar();   // Instancia do objeto no "heap" - Mais lento e mais complexo gerenciar
    p->xpto(50);                 
    delete p;                    // Instancias de objetos no "heap" precisam ser desalocadas


    Foobar f;        // RECOMENDADO: Instancia do objeto no "stack" - Mais rapido e mais facil gerenciar
    f.xpto(50);
}