Contar objetos instanciados [RESOLVIDO]

1. Contar objetos instanciados [RESOLVIDO]

SamL
(usa XUbuntu)

Enviado em 10/08/2016 - 20:27h

Eu preciso contar quantas vezes um objeto de determinada classe foi instanciado, no meu código isso é o id único de cada objeto. Segue um exemplo de código:

class Base

{

  static int id;

  public:

    Base (  ){

       id++;

   }



  int get_id (  ){

    return id;

  }

};

int Base::id = 0;



class Derivada1: public Base

{

};

...

Só que fico com a impressão de que minha classe Base está com uma gambiarra nesse id do tipo int. Eu não vou precisar de mais de 200 objetos derivados de Base. Mesmo assim, tem algum modo melhor de fazer isso?

0 0

Quote

2. MELHOR RESPOSTA

paulo1205
(usa Ubuntu)

Enviado em 11/08/2016 - 13:26h

Tem um jeito de não precisar copiar o incremento do ID em cada instância: transformar o ID em campo não-estático e usar para ele um tipo que definido por usuário que se encarregue de fazer a contagem.

class Base {

  private:

    class auto_inc_id {

      friend Base;

      static unsigned id;

      unsigned _id;

      auto_inc_id(){ _id=id++; }

      operator unsigned(){ return _id; }

    } id;



  public:

    unsigned get_id(){ return id; }



  /* Restante da classe Base vai aqui. */

};

1 0

Quote

3. Re: Contar objetos instanciados [RESOLVIDO]

removido
(usa Nenhuma)

Enviado em 10/08/2016 - 21:07h

Se fosse uma função, eu criaria uma variável static para contar quantas vezes ela seria chamada.

tipo funcao (parametros) {

    

    static int id = 0;

    id++;



    (...)



   return etc ...



}

----------------------------------------------------------------------------------------------------------------
Nem direita, nem esquerda. Quando se trata de corrupção o Brasil é ambidestro.
(anônimo)

Encryption works. Properly implemented strong crypto systems are one of the few things that you can rely on. Unfortunately, endpoint security is so terrifically weak that NSA can frequently find ways around it. — Edward Snowden

0 0

Quote

4. Re: Contar objetos instanciados [RESOLVIDO]

uilianries
(usa Linux Mint)

Enviado em 11/08/2016 - 09:21h

O padrão do C++11 especifica 6 operadores padrões, vai precisar sobreescrever, pelo menos o construtor para contar:



#include <iostream>

#include <utility>



struct Foo {

    Foo() {

        static auto c_default_constructor = 0;

        std::cout << "Construtor padrão: " << ++c_default_constructor << '\n';

    }

    Foo(const Foo&) {

        static auto c_copy_construtor = 0;

        std::cout << "Construtor por cópia: " << ++c_copy_construtor << '\n';

    }

    Foo(Foo&&) {

        static auto c_move_construtor = 0;

        std::cout << "Construtor por move: " << ++c_move_construtor << '\n';

    }

    ~Foo() {

        static auto c_default_destructor = 0;

        std::cout << "Destrutor padrão: " << ++c_default_destructor << '\n';

    }

    Foo& operator=(const Foo&) {

        static auto c_copy_assignment = 0;

        std::cout << "Assinatura por cópia: " << ++c_copy_assignment << '\n';

    }

    Foo& operator=(Foo&&) {

        static auto c_move_assignment = 0;

        std::cout << "Assinatura por move: " << ++c_move_assignment << '\n';

    }

};



int main() {

    Foo foo;

    Foo foobar(foo);

    Foo qux(std::move(foobar));

    qux = foo;

    foo = std::move(qux);



    return 0;

}

A saída será:

Construtor padrão: 1
Construtor por cópia: 1
Construtor por move: 1
Assinatura por cópia: 1
Assinatura por move: 1
Destrutor padrão: 1
Destrutor padrão: 2
Destrutor padrão: 3

--
Uilian Ries
Linux Counter: 521986

1 0

Quote