Uso de Namespaces

Ruthless — Thu, 24 Aug 2023 12:00:44 +0000

Em C++, é comum iniciarmos o código utilizando "using namespace std" após a declaração das bibliotecas:

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
}

Std vem da palavra "standard", que significa "padrão" em inglês. Ou seja, é como se estivéssemos utilizando uma biblioteca padrão da linguagem para fazermos operações e declarações, como variáveis, funções, structs, etc.

Mas afinal, o que é "Namespace"?

Namespaces são como pastas de organização no código, onde você guarda diferentes coisas. No exemplo acima, estamos usando a pasta padrão, onde colocamos as coisas que queremos usar em todo o código. Essas "pastas" geralmente são chamadas de escopo.

A necessidade de usar namespaces em um código pode gerar questionamentos, mas a resposta é direta. Através dessa palavra-chave, podemos evitar conflitos de nomes e usar os mesmos nomes para variáveis, funções e outros elementos de dados sem problemas. Em outras palavras, podemos utilizar o mesmo nome de um elemento para escopos diferentes. Isso torna o código eficiente para equipes que utilizam diversas bibliotecas criadas independentemente, evitando possíveis erros por conta de nomes iguais.

Como utilizo?

Uma forma de utilizar o namespace é declarando de forma similar a criação de classes, porém utilizando a palavra-chave namespace, e o nome do escopo que deseja, como veremos no exemplo abaixo:

using namespace std;

namespace NamespaceLocal {
    int variavel = 5;
}

Para termos acesso a variável específica declarada dentro da NamespaceLocal, utilizaremos seu nome, dois "dois-pontos" (::) e o nome da variável:

int main() {

    int variavel = 10;

    cout << "Variavel global: " << variavel << endl;

    cout << "Variavel local: " << LocalNamespace::variavel << endl;

    return 0;
}

Percebe-se que dentro a função main, declaramos uma variável com o mesmo nome, mas com diferente valor. Essa variável está ligada ao namespace std, e pode ser acessada normalmente, como exemplificado na primeira saída. Já na segunda saída, a variável foi acessada de forma específica ao NamespaceLocal. A saída será essa:

Variavel global: 10
Variavel local: 5

Outra forma de especificar o escopo, é utilizando a palavra using dentro da função, e todo os dados a partir dessa palavra estará atrelado ao escopo especificado.

namespace primeiro_namespace{
   void func(){
      cout << "Dentro do primeiro_namespace" << endl;
   }
}

namespace segundo_namespace{
   void func(){
      cout << "Dentro do segundo_namespace" << endl;
   }
}

using namespace primeiro_namespace;
int main () 
{
   func();

   return 0;
}

Utilizamos dois namespaces distintos, cada um com uma função de mesmo nome. No entanto, antes de invocarmos a função, estabelecemos o escopo inicial usando using namespace, o que resulta na chamada exclusiva da função associada a esse escopo. A saída será essa:

Dentro do primeiro_namespace

Entendendo Membros Estáticos

Ruthless — Fri, 18 Aug 2023 13:47:02 +0000

Contextualizando o acesso aos membros

Ao gerenciar informações de um estoque, é comum a coleta de dados essenciais como nome dos produtos, quantidades e valores. Ao desenvolver uma classe dedicada a essa finalidade, incorporamos membros específicos para cada conjunto de dados que desejamos armazenar. Demonstraremos esse processo por meio de um exemplo prático: a criação de uma aplicação em C++ para gerenciar um estoque de eletrônicos. Nessa aplicação, os detalhes pertinentes aos eletrônicos serão registrados e coletados através de um construtor dedicado, atribuindo seu respectivo nome, quantidade, valor, e atualizando os dados do estoque geral de acordo com as entradas.

class EstoqueEletronicos{
      private:
      string nome;
      int quantidade;
      int valor;

      int variedadeProdutos = 0;
      int estoqueTotal = 0;
      float gasto = 0;

      public:
      EstoqueEletronicos(string Nome, int Quantidade, int Valor)
      {
          /*construtor para atribuir as informações aos membros 
          privados da classe*/

          this->nome = Nome;
          this->quantidade = Quantidade;
          this->valor = valor;

          variedadeProdutos++;
          estoqueTotal += quantidade;
          gasto = valor * quantidade;
      }
};

Quando quisermos acessar os respectivos dados da classe, como a classe criada acima, precisaremos criar objetos que trabalham como "intermediários", para que possamos trabalhar em seus membros:

EstoqueEletronicos item1("Celular", 50, 1000);
EstoqueEletronicos item2("Notebook", 20, 3500);

No trecho acima, criamos 2 objetos específicos (item1, item2) para 2 itens que vamos armazenar no estoque, dentro da classe.

O que são membros estáticos e por que usar?

Antes de dizer o que são membros estáticos, devemos perceber o que está de fato acontecendo nos códigos acima. Notem que criamos dois objetos para armazenar dois itens no estoque, no entanto, essa maneira de armazenamento de dados para esse caso é ineficiente. Para entender melhor, a imagem abaixo mostrará o que acontece na memória:

Nesse método de armazenamento, estamos criando separadamente dois estoques para itens diferentes, o que é ineficiente, porque normalmente há apenas um estoque para todos os itens. Em vez disso, precisamos encontrar uma maneira de compartilhar e reutilizar um único estoque para todos os produtos, de forma que fique assim:

Para isso, usaremos os membros estáticos, que nos permitem acessar e manipular dados de uma classe sem a necessidade de atribuir um objeto. Ou seja, independente de quantas coisas armazenamos, o estoque seguirá sendo apenas um. Para utilizar esses membros, usamos a palavra-chave Static.
Vejamos como aplicar isso em nosso código:

class EstoqueEletronicos{
      private:
      string nome;
      int quantidade;
      int valor;

      /*utilizando a palavra-chave 'Static' para 
      informações do estoque*/
      static int variedadeProdutos++;
      static int estoqueTotal += quantidade;
      static float gasto = quantiade * valor;

      public:
      EstoqueEletronicos(string Nome, int Quantidade, int Valor)
      {  
          this->nome = Nome;
          this->quantidade = Quantidade;
          this->valor = valor;

          variedadeProdutos++;
          estoqueTotal += quantidade;
          gasto = valor * quantidade;
      }
};

Assim como mudamos a forma de criação de informações para membros estáticos, sua forma de acesso também é alterada, já que não precisamos de criação de objeto para isso. Usamos o tipo do objeto, o nome da classe junto de dois "dois-pontos" (::), mais o nome do membro estático. Como exemplo, inicializaremos o estoque em 0 fora da classe para impedir que os números sejam resetados sempre que o construtor é chamado:


int EstoqueEletronicos::variedadeProdutos = 0;
int EstoqueEletronicos::quantidade = 0;
int EstoqueEletronicos:: gasto = 0;

Como devo usar os membros estáticos?

Por não haver uma criação de objetos específicos para membros estáticos, podemos somente manipular esses dados com outros membros estáticos. Suponhamos que queremos criar um método para exibir os números do estoque, para que isso seja possível, também usaremos a palavra-chave Static em nossa função:

static void mostrar()
     {
      cout << "Variedade de produtos: " << variedadeProdutos << endl;
        cout << "Estoque total: " << estoqueTotal << endl; 
        cout << "Gasto total: " << gasto << endl;
}

Apesar do método acima ser estático, é possível criar objetos temporários dentro do mesmo, para lidarmos com membros não-estáticos, mas precisamos entender que esses objetos temporários não afetam os dados já existentes e armazenados na classe.