Design e uso orientado a objetos C ++

Programação Orientada a Objetos (OOP)

Orientado a Objetos (Orientado a Objetos) é um método de compreensão de assuntos, uma forma de pensar centrada no objeto

Programação orientada a objetos:

Objeto = (algoritmo + estrutura de dados)
programa = objeto + objeto + …… + objeto

A programação orientada a objetos simula os métodos de compreensão e processamento de coisas na natureza, colocando dados e métodos operacionais em dados juntos para formar um objeto inteiro relativamente independente. Objetos semelhantes também podem abstrair semelhanças e formar classes.). Os dados em uma classe geralmente só podem ser processados ​​por meio dos métodos fornecidos por essa classe, e esses métodos se tornam a interface entre a classe e o exterior. Os objetos se comunicam por meio de mensagens.

Chamamos as informações veiculadas pela interação entre os objetos de mensagens.

C ++ trata "enviar uma mensagem para um objeto" em "chamar uma determinada função-membro do objeto"

Objeto-conceito básico

Todas as coisas no mundo podem ser chamadas de Objetos. O objeto pode ser tangível, como um aparelho de televisão, etc. Também pode ser intangível, como uma conta, um registro, etc.

Um objeto é uma coisa objetiva independente, que consiste em um conjunto de atributos e um conjunto de operações que operam sobre os atributos.

• Propriedades são a descrição das características estáticas do objeto
• Operação é a descrição das características dinâmicas do objeto

Atributos e operações são os dois principais elementos de um objeto. Por exemplo, os atributos da TV são: marca, tamanho, peso, etc. As operações incluem: visualização, seleção de canal, ajuste de volume, etc.

Aula de conceito básico

Uma classe é um conceito abstrato usado para descrever as propriedades essenciais e comportamentos de classe compartilhados por uma determinada classe de objetos.

A realidade simulada resume e divide as coisas objetivas de acordo com princípios abstratos.

As características básicas da orientação a objetos

• resumo
• Encapsulamento e ocultação de dados (uma breve introdução)
• herdar
• Polimorfismo

Encapsulamento e ocultação de dados

O encapsulamento refere-se à combinação dos atributos e operações de um objeto para formar um objeto independente de acordo com o princípio de blindagem de informações.

Ao restringir os direitos de acesso a atributos e operações, os atributos podem ser "ocultos" dentro do objeto e uma determinada interface pode ser fornecida para o exterior, e o objeto só pode ser operado por meio da interface fora do objeto.

O encapsulamento aumenta a independência do objeto, garantindo assim a confiabilidade dos dados.

Objetos externos não podem manipular diretamente as propriedades do objeto, mas só podem usar os serviços fornecidos pelo objeto.

Ideias de design abstrato

Abstração de dados em atributos

O processo de processamento é abstraído em operações (métodos) -
Por exemplo: ao construir um sistema de gerenciamento de biblioteca, instintivamente saiba que deve haver objetos como bibliotecários / leitores / livros no sistema, e o comportamento dos leitores inclui empréstimo / devolução de livros, Os alunos também têm sua identificação de aluno / nome / classe, etc.

Definição de classe

C ++ suporta encapsulamento e ocultação de dados estabelecendo classes de tipos de dados. Uma classe bem definida pode ser usada como um módulo independente.

O formato de definição da classe é dividido em uma parte de descrição e uma parte de implementação
- a parte de descrição contém membros de dados e descrições de função de membro
- a parte de implementação é usada para definir funções de membro

O formato de definição geral de uma classe é o seguinte:

class  <类名>
{
    
    
	public :
		<公有数据成员和成员函数>;
	protected:
        <保护数据成员和成员函数>;
	private :
        <私有数据成员和成员函数>;
};

classA chave para definir a classe é o especificador de tipo de dados, <nome da classe> é um identificador, usado para identificar exclusivamente uma classe (novo tipo de dados), a parte das chaves após o nome da classe é o corpo da classe (Corpo da Classe) .

O corpo da classe define a lista de membros da classe (Lista de Membros de Classe) -membro de
dados (Membro de Dados)
-função (Função de Membro)

public, protected e private são especificadores de acesso

Geralmente, os membros públicos são explicados primeiro no corpo da classe, são eles que interessam ao usuário e, em seguida, os membros privados são explicados posteriormente. Eles não são do interesse do usuário, mas essa ordem não é necessária.

***Nota:

① Um ponto e vírgula ";" deve ser adicionado após a descrição da classe.

② A definição da classe é colocada em um arquivo de cabeçalho (.h) para outros arquivos que precisam usar a classe para incluir

③ A parte de implementação da classe é colocada em um arquivo de origem (.cpp), que precisa incluir o arquivo de cabeçalho que define a classe

④ A definição e implementação da classe podem ser colocadas em um arquivo, mas não é recomendado porque a estrutura não é clara, o que afeta a legibilidade do programa

Membro de dados (atributo)

Os tipos de membros de dados em uma classe podem ser arbitrários e vários tipos de variáveis, ponteiros, arrays, etc. podem ser definidos e até mesmo objetos de outras classes.

Ao descrever membros de dados, geralmente de acordo com o tipo e tamanho do membro de dados, de pequeno a grande, isso pode melhorar a utilização do espaço.

Apenas membros de dados podem ser declarados na definição de classe e os membros de dados definidos não podem ser inicializados.

Os membros de dados da classe só podem ser declarados na classe, e os membros de dados da classe são preferencialmente privados

A função externa precisa modificá-lo e geralmente fornece apenas uma interface de função pública, permitindo que acesse os dados privados da classe por meio da função de membro pública da classe. Os membros de dados também podem ser colocados na parte pública, mas não é recomendado

Função de membro (método)

As funções de membro podem usar diretamente qualquer membro na definição de classe, podem processar membros de dados e também podem chamar funções de membro.

A definição da função de membro de uma classe geralmente pode assumir duas maneiras, a saber, definição externa e definição interna (não recomendado! Ela afeta a legibilidade do programa).

A implementação de funções de membro geralmente é colocada fora da classe, e o protótipo da função é declarado na classe

Quando a implementação de uma função de membro está fora da definição de uma classe, ela deve ser declarada, e o nome da classe e o operador de escopo "::" são adicionados antes do nome da função para indicar a qual classe uma função de membro pertence. o formato é o seguinte:

返回类型  类名::成员函数名(参数说明)
{
    
    
	函数体 
}

A implementação de funções de membro de classe também pode ser colocada na classe sem adicionar o nome da classe e o operador de escopo

Controle de acesso

Três especificadores de acesso: público, privado e protegido

Função: controlar o acesso aos membros da classe

Na classe definida por classe, o método de acesso padrão é privado

Na definição da classe, todos os três especificadores de acesso podem ser usados ​​várias vezes (não recomendado). Seu escopo vai do aparecimento do especificador até o final antes do próximo especificador ou o final do corpo da classe.

Descrição do visitante

privado: membros privados de uma classe só podem ser acessados ​​por funções de membro, funções de amigo e classes de amigo da classe, e não podem ser acessados ​​fora da classe

protegido: Os membros protegidos da classe podem ser acessados ​​pelas funções de membro, funções de amigo, classes de amigo e funções de membro de classe derivada da classe

public: os membros públicos da classe podem ser acessados ​​diretamente pelas funções de membro, funções de amigo e todos os códigos de programa externos da classe de amigo que podem acessar os objetos da classe. Esta parte costuma ser algumas operações (ou seja, funções de membro)

Os membros públicos da classe são a interface externa da classe

Função de classe

A classe define as propriedades de controle de acesso de funções (métodos) e dados (atributos)
- quais membros podem ser acessados ​​diretamente pelo mundo externo
- quais membros só podem ser acessados ​​por suas próprias funções de membro

A tecnologia de encapsulamento e ocultação de informações torna a aula muito segura

Membros de dados privados só podem ser acessados ​​pelas funções de membro da própria classe

Contanto que a operação da função de membro seja razoável e legal, o objeto é seguro

Melhorar a capacidade de manutenção do programa

Definição de objeto

Objetos são instâncias de classes. O objeto pertence a uma classe conhecida.

Antes de definir um objeto, você deve primeiro definir a classe do objeto.

A classe definida pode ser usada como um novo tipo de dados

A sintaxe da declaração: 类的名称 对象的名称;
Por exemplo:

例如：
Stack oneStack;		//Stack类型的对象
Stack arrayOfStack[10]; //Stack类型的对象数组
Stack *pStack=&oneStack;	//Stack类型的指针
Stack &s = oneStack;  // 引用一个Stack对象

Construtor

Para a inicialização do objeto, o construtor é usado. Escreva um ou um conjunto de construtores. Construtor é uma função de membro especial

A função do construtor: alocar espaço para o objeto; atribuir valores iniciais aos membros dos dados; solicitar outros recursos.

Como declarar um construtor:
—O nome da função e o nome da classe são exatamente iguais
- O tipo (tipo de retorno) do construtor não pode ser definido e vazio
—O construtor deve ser declarado como uma função pública, mas não pode ser chamado explicitamente como outras funções de membro - o
construtor pode ter qualquer tipo e qualquer número de parâmetros, e uma classe pode ter vários construtores (sobrecarregando)

Ao criar um objeto de uma classe, o construtor da classe é automaticamente chamado

Apenas um construtor é chamado quando um objeto é criado (de acordo com a lista de parâmetros) e apenas uma vez quando é criado

Tipos de construtor

Construtor comum: um construtor com dois ou mais parâmetros

Construtor padrão

Construtor de cópia (cópia)

Construtor de conversão de tipo

Construtor sobrecarregado

Quando uma classe precisa aceitar diferentes valores de inicialização, é necessário escrever vários construtores, que constituem um relacionamento de sobrecarga.

Exemplo:

class Student{
    
    
private:
	char m_No[4],m_Name[21];
	int m_Age,m_Score[5];
public:
	Student();	//默认构造函数
	Student(char *name,int age,int score[5]);   //重载构造函数
};

Construtor padrão

• Qual construtor é o construtor padrão?

  Um construtor sem parâmetros ou todos os parâmetros têm valores padrão.

• Existe um construtor padrão na classe?

  Se nenhum construtor for declarado na classe, o compilador gerará automaticamente um construtor sem parâmetros padrão público; se houver uma declaração do construtor, o compilador não gerará um construtor padrão

• Quando o construtor padrão é chamado?

  Quando o objeto não é especificado para ser inicializado, o objeto é inicializado de acordo com o construtor padrão.
  Por exemplo: Person p1, p2; // Use o construtor padrão para inicializar p1 e p2

• Só pode haver um construtor padrão em uma classe
  (se todos os parâmetros de um construtor têm valores padrão, então não faz sentido definir um construtor padrão sem parâmetros, o que causará ambigüidade ao chamar)

Use parâmetros padrão no construtor

Você pode especificar os valores padrão dos parâmetros para as funções de membro da classe, incluindo o construtor.

Para colocar o valor do parâmetro padrão na declaração da função, não na definição da função

Se todos os parâmetros de um construtor têm valores padrão, então não faz sentido definir um construtor padrão sem parâmetros, o que causará ambigüidade ao chamar.

Exemplo:

class CCube{
    
    
public:
	CCube(double len);
	CCube(int len=12);
	//CCube();
private:
	double m_len;
};
CCube::CCube(int len){
    
    m_len=len;}

Construtor de cópia (cópia)

Construtor especial

Função: Use um objeto existente para inicializar um novo objeto desta classe

Declaração: Existe apenas um parâmetro e o parâmetro é uma referência a este tipo de objeto

class 类名{
    
    
	public:	类名(类名  &对象名);
	};

Se o construtor de cópia não for especificado na classe, o sistema gerará automaticamente um construtor de cópia padrão como um membro público da classe.

Cópia rasa e cópia profunda Cópia
rasa: simplesmente copie o valor do membro de dados do objeto
Cópia profunda: não apenas copie o valor do membro de dados do objeto, mas também gere novo espaço para o membro de dados do ponteiro e, em seguida, copie o valor correspondente

Exemplos:

#include <string.h>
#include <iostream.h>
class Employee
{
    
    
public:
	Employee(char *n);
	Employee(Employee &emp);
	~Employee();
public:
   char *name;
};
Employee::~Employee()
{
    
    //析构函数
	delete [] name;
}
Employee::Employee(char *n)
{
    
    
	name = new char[strlen(n)+1];
	strcpy(name,n);
}
Employee::Employee(Employee &emp)
{
    
    
	int len=strlen(emp.name);
	name=new char[len+1];
	strcpy(name,emp.name);
}
int main()
{
    
    
	Employee emp1("zhang");
	Employee emp2(emp1);
	//Employee emp2=emp1;
	cout<<"emp2.name = "<<emp2.name<<endl;
	return 0;
}

** Observação: quando o objeto contém membros de dados alocados dinamicamente, a implementação do construtor de cópia não pode ser apenas uma atribuição simples. Você deve alocar um novo espaço para os membros de dados do objeto atual e, em seguida, copiar os dados correspondentes no objeto de parâmetro.

Outras funções do construtor de cópia

Quando o parâmetro formal da função é o objeto da classe, ao chamar a função, ele é usado quando o parâmetro formal é combinado. Neste momento, crie um novo objeto local na memória e copie os parâmetros reais para o novo objeto. Obviamente, o construtor de cópia também é chamado.

Quando o valor de retorno da função é um objeto de classe, ele é usado quando a execução da função é concluída e retorna ao chamador. O motivo é criar um objeto temporário e, em seguida, retornar ao chamador. Por que não usar apenas o objeto local a ser retornado? Como o objeto local morre ao deixar a função que o criou, é impossível sobreviver após retornar à função de chamada, portanto, ao lidar com essa situação, o sistema compilador criará um objeto temporário sem nome na expressão da função de chamada. Este temporário O ciclo de vida de um objeto está apenas na expressão na chamada de função. O chamado objeto de retorno está, na verdade, chamando o construtor de cópia para copiar o valor do objeto em um objeto temporário. Se a variável for retornada, o processamento é semelhante, exceto que o construtor não é chamado.

Construtor de conversão

Fornece um construtor com um único parâmetro

É equivalente a converter um valor ou variável de outro tipo em dados de seu próprio tipo.

É muito perigoso que o construtor de uma classe tenha apenas um parâmetro, porque o compilador pode usar esse construtor para converter implicitamente o tipo do parâmetro para o tipo de classe

Exemplos:

#include <string.h>
#include <iostream.h>
class CCube
{
    
    
public:
	CCube(double len)
	{
    
    
		m_len=len;
	}
public:
	double m_len;
};
int main()
{
    
    
	CCube cube=12.4;
	cube=11;    //隐式转换
	cout<<"cube.m_len = "<<cube.m_len<<endl;
	return 0;
}

执行结果：
cube.m_len = 11

palavra-chave explícita

Palavras-chave usadas apenas para o construtor da classe.

O compilador não usará o construtor declarado como explícito para a conversão implícita, ele só pode exibir e criar objetos no código do programa

#include <string.h>
#include <iostream.h>
class CCube
{
    
    
public:
	explicit CCube(double len)
	{
    
    
		m_len=len;
	}
private:
	double m_len;
};
int main()
{
    
    
	CCube cube = 12.4;//不允许
	//cube=11;//不允许
	return 0;
}

Destruidor

Função especial de membro

Função: Faça o trabalho de limpeza antes de revogar o objeto, geralmente para liberar o espaço aplicado dinamicamente durante a vida do objeto

Quando o objeto excede seu escopo definido (ou seja, quando o objeto é liberado), o compilador chama automaticamente o destruidor.
-O objeto é definido no corpo da função, quando a função termina, o destruidor do objeto é chamado automaticamente.
- O objeto é criado dinamicamente usando o operador new, quando o operador delete é usado para liberá-lo, delete irá chamar automaticamente o destruidor

O nome da função é semelhante ao nome da classe (com um caractere "~" na frente)

Nota: O destruidor não tem tipo de retorno, nenhum parâmetro e o destruidor não pode ser sobrecarregado

Se nenhum destruidor for definido, o compilador gerará automaticamente um destruidor padrão com o seguinte formato:

类名::~默认析构函数名( )
{
    
    
}

O destruidor padrão é uma função vazia.

Exemplo:

class Student
{
    
    
public:
	 Student();
	~Student();
private:
	char *m_name;
};
Student :: Student()
{
    
    
	cout<<"Default constructor called"<<endl;
	m_name=new char[5];
	strcpy(m_name,"abc");
}
Student ::~Student()
{
    
    
	cout<<"Free"<<endl;
	delete []char;
}