Sobrecarga em C ++

O C ++ não permite uma função que adiciona dois números inteiros e retorne um número inteiro, para adicionar dois carros alegóricos e retornar um flutuador. Imagine que há uma função para adicionar dois números inteiros e devolver um número inteiro. Não seria bom ter outra função com o mesmo nome, que adiciona apenas dois ou mais carros alegóricos para retornar um flutuador? Diz -se que está, sobrecarregando a primeira função.

Os operadores aritméticos são normalmente usados ​​para operações aritméticas. Não é bom ter o +, junte -se a duas cordas? Permitindo que isso esteja sobrecarregando o operador de adição aritmética, para strings.

O operador de incremento, ++ adiciona 1 a um int ou um flutuador. Ao lidar com ponteiros, ele não adiciona 1 ao ponteiro. Faz o ponteiro apontar para o próximo objeto consecutivo na memória. Um iterador aponta para o próximo objeto em uma lista vinculada, mas os objetos da lista vinculada estão em lugares diferentes na memória (não em regiões consecutivas). Não seria bom sobrecarregar o operador de incremento para um iterador, para incrementar, mas apontar para o seguinte elemento, na lista vinculada?

Este artigo explica a sobrecarga em C++. É dividido em duas partes: sobrecarga de função e sobrecarga do operador. Já é necessário ter conhecimento básico em C ++ para entender o restante do artigo.

Conteúdo do artigo

• Sobrecarga da função
• Sobrecarga do operador
• Exemplo de sobrecarga do operador de classe String
• Sobrecarga do operador do iterador
• Conclusão

Sobrecarga da função

A função a seguir adiciona duas ints e retorna um int:

int add (int no1, int no2)

int sum = no1 + no2;
soma de retorno;

O protótipo desta função é:

int add (int no1, int no2);

O protótipo de uma função no cabeçalho da função, terminando com um semicolon. A função a seguir com o mesmo nome, mas com um protótipo diferente, adicionaria três carros alegóricos e devolveria um flutuador:

Float Add (Float No1, Float No2, Float No3)

soma float = NO1 + NO2 + NO3;
soma de retorno;

Como o compilador diferencia qual funciona a chamar, já que duas ou mais funções têm o mesmo nome? O compilador usa o número de argumentos e tipos de argumentos para determinar qual função chamar. A lista de parâmetros de funções sobrecarregadas deve diferir em seus tipos de número e/ou parâmetros. Então, a chamada de função,

int sm = add (2, 3);

chamaria a função inteira, enquanto a chamada de função,

Float SME = Adicionar (2.3, 3.4, 2.0);

chamaria a função de flutuação. Nota: Existem situações em que o compilador rejeitará uma função sobrecarregada quando o número de argumentos for o mesmo, mas de tipos diferentes! - Motivo: - Veja mais tarde.

O programa a seguir coloca os segmentos de código acima em ação:

#incluir
usando namespace std;
int add (int no1, int no2)

int sum = no1 + no2;
soma de retorno;

Float Add (Float No1, Float No2, Float No3)

soma float = NO1 + NO2 + NO3;
soma de retorno;

int main ()

int sm = add (2, 3);
cout<Float SME = Adicionar (2.3, 3.4, 2.0);
cout<retornar 0;

A saída é:

5
7.7

Sobrecarga do operador

Os operadores aritméticos são usados ​​para sobrecarregar operações nos tipos de classe. Um iterador é do tipo de classe. Os operadores de incremento e decréscimos são usados ​​para sobrecarregar operações para um iterador.

Exemplo de sobrecarga do operador de classe String

Esta seção fornece um exemplo, onde + é sobrecarregado para uma classe de string simplesmente projetada, chamada de classe de mola. + concatena os literais de dois objetos de string, devolvendo um novo objeto com os literais concatenados. Concatenando dois literais significa se juntar ao segundo literal até o final do primeiro literal.

Agora, o C ++ tem uma função de membro especial para todas as classes, chamada de operadora. O programador pode usar esta função especial para sobrecarregar os operadores, como +. O programa a seguir mostra a sobrecarga do operador + para duas strings.

#incluir
usando namespace std;
Spring de classe

público:
// membros de dados
Char Val [100];
int n;
Char Concat [100];
// Funções de membros
primavera (char arr [])

para (int i = 0; i<100; ++i)
val [i] = arr [i];
if (arr [i] == '\ 0')
quebrar;

int i;
para (i = 0; i<100; ++i) if (arr[i] == '\0') break;
n = i;

Operador de primavera+(Spring & st)
int newlen = n + st.n;
Char Newstr [Newlen+1];
para (int i = 0; ipara (int i = n; inewstr [newlen] = '\ 0';
OBJ da primavera (Newstr);
retornar obj;

;
int main ()

char ch1 [] = "eu te odeio! "; Spring str1 (CH1);
char ch2 [] = "mas ela te ama!"; Spring str2 (CH2);
char ch3 [] = "um"; Spring STR3 (CH3);
str3 = str1 + str2;
cout<retornar 0;

O valor de str1 é "eu te odeio! ". O valor de STR2 é "mas ela te ama!". O valor de STR3, que é, str1 + str2, é a saída:

"Te odeio! Mas ela te ama!"

que é a concatenação dos dois literais de cordas. As próprias cordas são objetos instantados.

A definição da função do operador está dentro da descrição (definição) da classe String. Começa com o tipo de retorno, "Spring" para "String". O nome especial, "Operador, siga isso". Depois disso, há o símbolo do operador (a ser sobrecarregado). Depois, há a lista de parâmetros, que na verdade é a lista de operando. + é um operador binário: o que significa que leva uma esquerda e um operando direito. No entanto, pela especificação C ++, a lista de parâmetros aqui tem apenas o parâmetro certo. Depois, há o corpo da função do operador, que imita o comportamento do operador comum.

Pela especificação C ++, a definição do operador+ leva apenas o parâmetro correto do operando, porque o restante da descrição da classe é o parâmetro de operando esquerdo.

No código acima, apenas a definição da função do operador + () está preocupada com a sobrecarga +. O restante do código para a classe é codificação normal. Dentro desta definição, os dois literais de cordas são concatenados na matriz, Newstr []. Depois disso, um novo objeto de string é realmente criado (instanciado), usando um argumento, Newstr []. No final da definição da função do operador+(), o objeto recém -criado, com a sequência concatenada, é retornado.

Na função Main (), a adição é feita pela declaração:

str3 = str1 + str2;

Onde str1, str2 e str3 são objetos de string que já foram criados em main (). A expressão, "STR1 +STR2" com seu +, chama a função de membro do operador +() no objeto STR1. A função de membro do operador+() no objeto STR1 usa STR2 como seu argumento e retorna o novo objeto com (desenvolvido) a string concatenada. O operador de atribuição (=) da declaração completa substitui o conteúdo (valores de variáveis) do objeto STR3, com os do objeto retornado. Na função Main (), após a adição, o valor do membro de dados STR3.Val não é mais "um"; É a string concatenada (adição), "eu te odeio! Mas ela te ama!". A função de membro do operador+() no objeto STR1, usa a string de seu próprio objeto literal e a string literal de seu argumento, STR2 para criar uma string literal unida.

Sobrecarga do operador do iterador

Ao lidar com o iterador, pelo menos dois objetos estão envolvidos: uma lista vinculada e o próprio iterador. De fato, pelo menos duas classes estão envolvidas: uma aula da qual uma lista vinculada é instanciada e uma classe da qual um iterador é instanciado.

Lista vinculada

Um diagrama para um objeto de lista duplamente ligada é:

Esta lista tem três elementos, mas pode haver mais. Os três elementos aqui são elementos de números inteiros. O primeiro tem o valor, 14; O próximo tem o valor, 88; e o último tem o valor, 47. Cada elemento aqui consiste em três locais consecutivos.

Isso é diferente da matriz, onde cada elemento é um local, e todos os elementos da matriz estão em locais consecutivos. Aqui, os diferentes elementos estão em diferentes lugares da série de memória, mas cada elemento consiste em três locais consecutivos.

Para cada elemento, o local do meio mantém o valor. O local certo tem o ponteiro para o próximo elemento. O local esquerdo tem o ponteiro para o elemento anterior. Para o último elemento, o local certo aponta para um fim teórico da lista. Para o primeiro elemento, o local esquerdo aponta para um início teórico da lista.

Com a matriz, o operador de incremento (++), incrementa o ponteiro para apontar para o local fisicamente próximo. Com a lista, os elementos não estão em regiões consecutivas na memória. Portanto, o operador de incremento pode ser sobrecarregado, mover o iterador (ponteiro) de um elemento para o elemento logicamente próximo. A mesma projeção se aplica ao operador de decréscimo (-).

Um iterador para a frente é um iterador que, quando engajado, aponta para o próximo elemento. Um iterador reverso é um iterador, que, quando engajado, aponta para o elemento anterior.

Sobrecarregamento ++ anúncio -

A sobrecarga desses operadores é feita na descrição da classe (definição) do iterador.

A sintaxe para o protótipo da sobrecarga do operador de incremento, prefixo, é

Operador de retornoType ++ ();

A sintaxe para o protótipo da sobrecarga do operador de incremento, pós -fix, é

Operador de returnType ++ (int);

A sintaxe para o protótipo da sobrecarga do operador de decréscimo, prefixo, é

Operador de retorno-();

A sintaxe para o protótipo da sobrecarga do operador de incremento, pós -fix, é

Operador de retorno-(int);

Conclusão

Sobrecarregar significa dar um significado diferente a uma função ou um operador. As funções estão sobrecarregadas no mesmo escopo. O que diferencia as funções sobrecarregadas são o número e/ou tipos de parâmetros em suas listas de parâmetros. Em alguns casos, onde o número de parâmetros é o mesmo, mas com tipos diferentes, o compilador rejeita a sobrecarga - veja posteriormente. Muitos operadores comuns podem ser sobrecarregados em classes das quais os objetos são instanciados. Isso é feito dando um tipo de retorno, lista de parâmetros e corpo, para a função especial nomeada, operadora, na descrição da classe.