classes objects c
Uma breve introdução a classes e objetos em C ++.
Classes e objetos são os blocos de construção da programação orientada a objetos em C ++. Cada entidade, viva ou não viva, pode ser representada como um objeto e programada de acordo com o C ++. Assim, entidades como um carro, uma mesa, uma pessoa, um pássaro, um animal etc. podem ser representadas como objetos.
Classe é um nível mais alto que o objeto e representa a categoria de objetos. Assim, a classe atua como um projeto que descreve o design e os detalhes do objeto. Isso inclui dados que são usados para descrever o objeto e vários métodos ou funções que podem atuar nos dados do objeto.
=> Veja a série de treinamento simples em C ++ aqui.
Neste tutorial, discutimos todos os detalhes de classe e objetos em C ++ junto com sua representação programática.
O que você aprenderá:
- Aulas
- Objetos
- Especificadores de acesso
- Construtores
- Tipos de construtores
- Operador de Atribuição
- Destroyers
- “Este” Pointer
- Conclusão
- Leitura recomendada
Aulas
Uma classe em C ++ pode ser vista como um projeto ou um esqueleto de uma entidade específica. Classe é um tipo de dados definido pelo usuário. Ele contém as informações ou dados gerais dessa entidade específica e as funções que operam nessa entidade.
Na sintaxe C ++, definimos uma classe com a palavra-chave “classe” seguida do nome da classe.
O nome da classe é seguido pelos detalhes da classe entre chaves e é encerrado por um ponto e vírgula.
O bloco a seguir mostra a sintaxe geral para a definição da classe.
Conforme mostrado na representação acima, a classe pode ter especificadores de acesso como public / protected / private. Ele pode ter membros de dados e funções de membro. Os dados e funções são chamados como membros da classe. Por padrão, os membros são privados da classe, de forma que nenhuma entidade externa tenha acesso a esses membros.
Por exemplo, um veículo pode ser uma classe generalizada com propriedades como modelo, cor, nº do chassi, velocidade_média, etc. Pode ter funções como alterarModelo, acelerar, desacelerar etc. que executam ações nos membros de dados. Podemos definir uma classe chamada “veículo” que terá todos esses membros de dados e funções.
Como já mencionado, uma classe é apenas um projeto para as entidades. Não ocupa nenhum espaço na memória quando é definido. Para que uma classe seja funcional, temos que definir objetos que possam fazer uso dos membros da classe.
Objetos
Para usar a funcionalidade da classe, precisamos instanciar a classe para criar um objeto. Um objeto é uma instância de uma classe. Em palavras simples, podemos dizer que um objeto é uma variável do tipo classe.
A sintaxe geral para criar um objeto é:
classname object_name;
Depois que o objeto é criado, ele pode ser usado para acessar os membros de dados e funções dessa classe.
O acesso aos membros da classe (dados e funções) é feito usando o operador ponto (.), Que também é chamado de operador de acesso ao membro.
Se obj é o nome do objeto e existe uma função “display ()” na classe, então a função pode ser acessada como “obj.display ()”.
No entanto, há um problema na declaração acima. Podemos acessar a função display () usando um objeto e o operador ponto se a função for “pública”.
Especificadores de acesso
Em C ++, acessar os membros de dados e funções na classe depende do acesso concedido a esse membro de dados ou função particular usando um especificador de acesso.
C ++ suporta os seguintes especificadores de acesso:
# 1) Privado
Este é o especificador de acesso padrão para uma classe em C ++. Isso significa que, se nenhum especificador de acesso for especificado para os membros de uma classe, ele será considerado privado.
Quando um membro é particular, ele não pode ser acessado fora da classe. Nem mesmo usando o objeto e o operador ponto. Os membros de dados privados só podem ser acessados usando as funções de membro da classe.
programas que usam c ++
No entanto, há uma exceção a essa regra, que discutiremos em nossos tópicos posteriores.
# 2) Público
Um membro de dados ou função definido como público na classe está acessível a todos fora da classe. Esses membros podem ser acessados usando o objeto e o operador ponto.
# 3) Protegido
Um membro protegido de uma classe está acessível à própria classe e às classes filhas dessa classe.
Este especificador de acesso é especialmente usado em caso de herança e discutiremos isso em detalhes ao discutir o tópico de herança.
Vejamos o exemplo a seguir para entender melhor esses especificadores de acesso.
#include #include using namespace std; class ABC{ int var1 = 10; public: string name; void display() { cout<<'var1 ='< Resultado:
var1 = 10
nome = sth
Neste programa, temos dois membros de dados dos quais var1 do tipo int é privado (especificador de acesso não especificado. O padrão é privado). Outro membro é o nome da string, que é declarado como público. Temos ainda outro display de função que exibe o valor de ambos os membros.
Na função principal, declaramos um objeto abc da classe ABC. Em seguida, definimos valores para membros de dados e também a exibição da função de chamada usando o objeto ‘abc’.
No entanto, quando o compilador encontra a linha abc.var1 = 20; irá gerar um erro de que “var1 é uma variável privada”.
Isso ocorre porque não podemos acessar membros de dados privados de uma classe fora da classe. Portanto, há um erro. Mas podemos acessá-lo dentro da função e, portanto, quando emitimos o valor de var1 na função de exibição; não gera nenhum erro.
Portanto, a saída do programa exibe o valor inicial com o qual var1 é declarado.
Até agora, vimos os detalhes sobre classes, objetos e especificadores de acesso, agora vamos dar um exemplo completo de um aluno de classe de amostra. Esta classe tem membros de dados: student_id, student_name e student_age. Ele também tem funções de membro para ler informações do aluno e exibir informações do aluno.
Para facilitar as coisas para os leitores, declaramos todos os membros da classe como públicos.
O programa a seguir mostra a implementação completa.
#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; void read_studentInfo(); void print_studentInfo() { cout<<'
Student ID : '<student_id; cout<>student_name; cout<>student_age; } int main() { student s1; s1.read_studentInfo(); s1.print_studentInfo(); }
Resultado:
Digite a ID do aluno: 1
Digite student_name: abc
Digite student_age: 12
ID do aluno: 1
Nome do aluno: abc
Idade do Aluno: 12
Assim, temos uma classe completa definida acima. A única diferença notável é que definimos uma função “print_studentInfo” dentro da classe, enquanto outra função “read_studentinfo” é definida fora da classe. Essas são as duas maneiras pelas quais as funções de membro podem ser definidas para uma classe.
Observe que a função que é definida externamente ainda possui uma declaração / protótipo dentro da classe. Além disso, é definido fora da classe usando o operador de resolução de escopo (: :) . Em seguida, na função principal, criamos um objeto de classe de aluno e, em seguida, chamamos funções para ler e exibir os dados.
Construtores
Até agora neste tutorial, criamos um objeto simples e atribuímos valores a cada membro de dados da classe na função principal após ler esses valores da entrada padrão.
Neste tópico, daremos uma olhada em uma função especial que é usada para inicializar o objeto durante sua criação. Essa função especial é chamada de construtor.
Um construtor é uma função-membro da classe, mas difere da função-membro normal das seguintes maneiras:
- O construtor não tem valor de retorno, ou seja, o construtor nunca retorna um valor.
- É uma função de membro público da classe.
- É usado para inicializar os membros de dados e construir o objeto da classe.
- Ele é chamado automaticamente pelo compilador quando o objeto está sendo criado.
Tipos de construtores
C ++ oferece suporte aos seguintes tipos de construtores.
# 1) Construtor padrão
Um construtor padrão é o construtor básico e não tem parâmetros. Podemos criar um objeto simples sem nenhum parâmetro usando o construtor padrão.
O construtor padrão tem a seguinte sintaxe:
classname() { //constructor code }
Se uma classe não tiver um construtor padrão, o compilador o criará.
# 2) Construtor parametrizado
Um construtor parametrizado é aquele que possui uma lista de parâmetros com a qual podemos inicializar os membros da classe. Quando declaramos um objeto em um construtor parametrizado, precisamos passar os valores iniciais para a função do construtor como parâmetros.
Uma função construtora parametrizada se parece com a mostrada abaixo.
classname(argument list){ //constructor code }
Um construtor parametrizado é usado para sobrecarregar os construtores. Veremos mais sobre sobrecarga em nossos tópicos posteriores.
Um construtor parametrizado é usado com o propósito de inicializar membros de dados de diferentes objetos. Enquanto fazemos isso, podemos passar diferentes valores de membros de dados para diferentes objetos.
# 3) Copiar construtores
C ++ oferece suporte a um terceiro tipo de construtor conhecido como construtor de cópia. Sua forma geral é
classname (const classname & obj);
Conforme mostrado na declaração acima, no construtor de cópia, um novo objeto é criado usando os valores de outro objeto da mesma classe. O parâmetro que é passado ao construtor é a referência constante de um objeto cujos valores serão utilizados para a construção do novo objeto.
Um construtor de cópia geralmente é chamado nas seguintes situações:
- Quando um objeto de classe é retornado por valor.
- Quando um objeto é passado para uma função como um argumento e é passado por valor.
- Quando um objeto é construído a partir de outro objeto da mesma classe.
- Quando um objeto temporário é gerado pelo compilador.
No entanto, não podemos garantir que o construtor de cópia certamente será chamado em todos os casos acima, pois o compilador C ++ tem uma maneira de otimizar as operações de cópia.
Um construtor de cópia realiza a cópia membro-a-membro entre objetos. Assim como o construtor padrão, o compilador C ++ cria um construtor de cópia padrão se não fornecermos um em nosso programa. Mas quando uma classe tem certos membros de dados como ponteiros, referências ou qualquer alocação de recursos em tempo de execução, então precisamos ter nosso próprio construtor de cópia definido pelo usuário.
O motivo é que o construtor de cópia padrão executa apenas uma cópia superficial de membros de dados, ou seja, ambos os objetos compartilharão o mesmo local de memória. Isso é bom para membros de dados não apontadores simples.
No entanto, quando se trata de ponteiros ou quaisquer outros membros de dados dinâmicos, gostaríamos que os dados fossem apontados para um novo local de memória. Esta é a cópia profunda e só pode ser obtida usando um construtor de cópia definido pelo usuário.
É dado a seguir um programa C ++ completo que implementa todos os três tipos de construtores e seu uso na construção de um objeto.
#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; //default constructor student(){ student_id = 1; student_name = 'abc'; student_age = 10; } //parameterized constructor student(int id,string name,int age){ student_id = id; student_name = name; student_age = age; } //copy constructor student(const student& st){ student_id = st.student_id; student_name = st.student_name; student_age = st.student_age; } void print_studentInfo() { cout<<'
Student ID : '< Resultado:
********** s **********
ID do aluno: 1
Nome do aluno: abc
Idade do Aluno: 10
site do provedor de dados para negócios online
********** s2 **********
ID do aluno: 2
Nome do aluno: xyz
Idade do Aluno: 12
A captura de tela para o mesmo é fornecida abaixo.

como ler arquivo .dat
Neste programa, definimos um aluno de turma semelhante ao definido no programa anterior. A diferença é que em vez de ler os valores dos membros de dados da entrada padrão por meio de uma função, definimos três construtores.
É absolutamente possível que uma classe tenha mais de um construtor. Temos um construtor padrão que inicializa os membros de dados para valores iniciais. Em seguida, definimos um construtor parametrizado que passa os valores iniciais como parâmetros para o construtor.
A seguir, definimos um construtor de cópia para o qual passamos uma referência constante a um objeto da classe do aluno.
Na função principal, criamos três objetos separadamente usando três construtores. O primeiro objeto s é criado usando o construtor padrão. O segundo objeto s1 é criado usando o construtor parametrizado enquanto o terceiro objeto s2 é criado usando um construtor de cópia.
Observe a criação do terceiro objeto s2. Aqui, atribuímos o objeto já criado s1 ao novo objeto s2. Portanto, quando construímos um novo objeto usando o objeto já existente, um construtor de cópia é chamado pelo compilador.
Operador de Atribuição
Também podemos atribuir os valores de um objeto a outro usando um operador de atribuição (=). Nesse caso, teremos uma instrução como s1 = s.
A diferença entre o construtor de cópia e o operador de atribuição é que, enquanto o construtor de cópia constrói um novo objeto, o operador de atribuição apenas atribui os valores de um membro do objeto no RHS aos do objeto no LHS. Isso significa que os objetos em ambos os lados de um operador de atribuição precisam existir antes da atribuição.
Destroyers
Um destruidor também é uma função especial como um construtor, mas implementa a funcionalidade exatamente oposta ao construtor. Enquanto o construtor é usado para criar um objeto, um destruidor é usado para destruir ou excluir um objeto.
Algumas das características do destruidor incluem:
- Um nome de destruidor é igual ao nome de classe, mas começa com um sinal de til (~).
- Destruidor não tem tipo de retorno.
- Um destruidor não tem argumentos.
- Só pode haver um destruidor em uma classe.
- O compilador sempre cria um destruidor padrão se deixarmos de fornecer um para uma classe.
A sintaxe geral de um destruidor é:
~classname(){ //cleanup code }
O destruidor de uma classe geralmente é chamado nas seguintes situações:
- Quando o objeto sai do escopo, o destruidor da classe é chamado automaticamente.
- Da mesma forma, o destruidor é chamado quando a execução do programa termina. Isso significa que todos os objetos também deixam de existir. Conseqüentemente, o destruidor de cada objeto será chamado.
- O destruidor da classe também é chamado quando o operador ‘delete’ para excluir um objeto é executado.
- Também podemos chamar o destruidor explicitamente para realizar qualquer atividade de limpeza depois que terminarmos com a funcionalidade do objeto.
O exemplo fornecido a seguir demonstra o funcionamento de um destruidor.
#include using namespace std; class sample{ public: sample(){ cout<<'Constructor::sample called'< Resultado:
Construtor :: amostra chamada
Esta é uma aula de amostra
Destrutor :: ~ amostra chamada
A captura de tela da saída acima é fornecida abaixo.

Definimos um exemplo de classe em que definimos um construtor, um destruidor e uma exibição de função. Na função principal, criamos um objeto obj de amostra de classe e, em seguida, chamamos a função de exibição neste objeto.
Depois disso, um retorno 0 é executado. Na saída, podemos ver que no momento em que a função display retorna e o controle do programa chega ao comando return 0, o destruidor é executado. Isso significa que ele é executado no momento em que o objeto sai do escopo.
“Este” Pointer
C ++ usa um conceito especial relacionado aos objetos, que é conhecido como ponteiro “este”. O ponteiro “this” sempre aponta para o objeto atual. Portanto, dependendo da situação, sempre que tivermos que nos referir ao objeto atual, usamos o ponteiro “this”.
Sabemos que sempre que uma instância da classe, ou seja, um objeto, é criada, uma cópia separada dos membros de dados da classe é feita para o objeto. Mas quando se trata das funções-membro da classe, todos os objetos compartilham a mesma cópia.
Portanto, quando um ou mais objetos acessam as funções-membro simultaneamente, como podemos garantir que os membros de dados apropriados sejam acessados e modificados pelas funções-membro?
Este é o lugar onde “este” ponteiro entra em ação. O compilador passa um ponteiro implícito com o nome da função como “this”. Isso é chamado de ponteiro “this”.
O ponteiro “this” é passado como um argumento oculto para todas as chamadas de função de membro. Geralmente é uma variável local. Conseqüentemente, “este” ponteiro é um ponteiro constante e seu conteúdo é o endereço de memória do objeto atual.
Observe que esse ponteiro está disponível apenas para funções de membro não estáticas e não para funções estáticas. Isso ocorre porque as funções estáticas não precisam ser acessadas por meio de um objeto. Eles podem ser acessados diretamente usando o nome da classe.
Normalmente usamos o ponteiro “this” em situações onde as variáveis de membro e os parâmetros são passados para inicializar as variáveis de membro que compartilham o mesmo nome. Também o usamos quando precisamos retornar o objeto atual da função.
Vejamos a demonstração do ponteiro “este” abaixo.
#include using namespace std; class Sample { private: int num; char ch; public: Sample &setParam(int num, char ch){ this->num =num; this->ch = ch; return *this; } void printValues(){ cout<<'num = '< Resultado:
num = 100
ch = A
No programa acima, temos uma classe chamada Sample, com num e ch de dois membros de dados. Temos uma função de membro setParam que passa os parâmetros com os mesmos nomes, num e ch para definir os valores das variáveis de membro.
Dentro da função, atribuímos esses valores às variáveis de membro do objeto atual indicadas por este ponteiro. Uma vez que os valores são definidos, o objeto atual “this” é retornado da função.
Na função principal, primeiro criamos um objeto da classe Sample, obj e chamamos uma função setParam para definir os valores e, em seguida, chamamos a função printValues para imprimir os valores.
Conclusão
Aprendemos os blocos de construção básicos de OOP em C ++ neste tutorial. Compreender as classes e objetos são os requisitos principais, para começar, OOP em C ++. Também aprendemos sobre os construtores e destruidores em detalhes com exemplos.
Em nosso próximo tutorial, aprenderemos sobre as listas de inicializadores em C ++.
=> Veja a série de treinamento simples em C ++ aqui.
Leitura recomendada
- Conceitos de Python OOPs (classes, objetos e herança de Python)
- Interface Java e tutorial de classe abstrata com exemplos
- Trabalhando com objetos VBScript Excel
- QTP Tutorial # 7 - QTP's Object Identification Paradigma - Como o QTP identifica objetos de forma única?
- Repositório de objetos em QTP - Tutorial # 22
- Trabalhando com objetos de conexão VBScript ADODB
- Polimorfismo de tempo de execução em C ++
- Herança em C ++