Trabalhando com Funções em C ++

Os desenvolvedores geralmente precisam da capacidade de quebrar programas em pedaços menores que são mais fáceis de desenvolver. programas de "mundo real" pode ser muitos milhares (ou milhões!) de linhas longas. Sem esta capacidade de dividir o programa em partes, o desenvolvimento de tais programas grandes iria rapidamente tornar-se impossível.

Conteúdo

C ++ permite que os programadores para dividir seu código em pedaços conhecido como funções. Uma função com uma descrição simples e uma interface bem definida para o mundo exterior pode ser escrito e depurado sem se preocupar com o código que o rodeia.

Sobrecarregando os nomes de funções

C ++ permite ao programador para atribuir o mesmo nome de duas ou mais funções. Este uso múltiplo de nomes como é conhecido sobrecarregar funções ou, simplesmente, sobrecarregando.

Em geral, duas funções em um único programa não podem compartilhar o mesmo nome. Se o fizessem, C ++ não teria nenhuma maneira de distingui-los.

No entanto, o nome da função inclui o número e tipo de seus argumentos. (O nome da função não incluir o seu argumento de retorno). Assim, o seguinte não são as mesmas funções:

someFunction void (void)
{
// .... Executar alguma função
}
vazio someFunction (int n)
{
// ... Executar alguma função diferente
}
someFunction void (double d)
{
// ... Executar alguma função muito diferente
}
someFunction vazio (int N1, N2 int)
{
// .... Fazer algo diferente ainda
}

C ++ ainda sabe que as funções someFunction (void), someFunction (int), someFunction (duplo), e someFunction (int, int) não são os mesmos. Como tantas coisas que lidam com computadores, isso tem uma analogia no mundo humano.

vazio como um tipo de argumento é opcional. sumFunction (void) e sumFunction () são a mesma função. A função tem um nome abreviado, como someFunction (). Enquanto nós usamos o nome inteiro, ninguém fica confuso - não importa quantas someFunctions podem existir. O nome completo de um dos someFunctions ()é someFunction (int). Enquanto este nome completo é única, nenhuma confusão ocorre.

Uma aplicação típica pode aparecer da seguinte maneira:

int intVariable1, intVariable2- // equivalente a
// Int Variable1-
// Int Variable2-
dupla doubleVariable-
// funções são distinguidas pelo tipo de
// O argumento passado
someFunction () - // chama someFunction (void)
someFunction (intVariable1) - // chama someFunction (int)
someFunction (doubleVariable) - // chama someFunction (duplo)
someFunction (intVariable1, intVariable2) - // chamadas
// SomeFunction (int, int)
// Isso funciona para constantes, bem
someFunction (1) - // chama someFunction (int)
someFunction (1,0) - // chama someFunction (duplo)
someFunction (1, 2) - // chama someFunction (int, int)

Em cada caso, do tipo dos argumentos coincide com o nome completo das três funções.


O tipo de retorno não é parte do nome estendida (também conhecido como o assinatura de função) Da função. As duas funções seguintes têm o mesmo nome e, assim, não pode ser parte do mesmo programa:

int someFunction (int n) - // nome completo da função
// É someFunction (int)
dupla someFunction (int n) - // mesmo nome

O que se segue é aceitável:

int someFunction (int n) -
double d = someFunction (10) - // Promover valor retornado

o int retornado pela someFunction () é promovido numa duplo. Assim, o seguinte seria confuso:

int someFunction (int n) -
someFunction dupla (int n) -
double d = someFunction (10) - // promover int retornado?
// Ou o uso retornou dupla como é

C ++ saberia se usar o valor retornado da duplo versão de someFunction () ou promover o valor retornado de int versão.

Definindo protótipos de função

O programador pode fornecer o resto de um C ++ ficheiro de origem, ou módulo, o nome prolongado (o nome e funções) durante a definição da função.

Uma função pode ser definida em qualquer parte do módulo. (UMA módulo é outro nome para arquivo de origem C ++.) No entanto, alguma coisa tem que dizer a Principal() o nome completo da função antes que pode ser chamado. Considere o seguinte trecho de código:

int main (int argc, pArgs char * [])
{
somefunc (1, 2) -
}
int somefunc (double arg1, arg2 int)
{
// ...faça alguma coisa
}

A chamada para somefunc () de dentro a Principal() não sabe o nome completo da função. Pode supor a partir dos argumentos de que o nome é somefunc (int, int) e que o seu tipo de retorno é no entanto void-, como você pode ver, isso é incorreto.

C ++ poderia ser menos preguiçoso e olhar em frente para determinar o nome completo somefunc ()s por conta própria, mas isso não acontece. O que é necessário é alguma forma de informar a Principal() do nome completo de somefunc () antes de ser usado. O que é necessário é uma declaração de função uso antes. Algum tipo de protótipo é necessário.

UMA declaração de protótipo aparece o mesmo como uma função sem corpo. Em uso, uma declaração protótipo aparece da seguinte forma:

int somefunc (double, int) -
int main (int argc, pArgs char * [])
{
somefunc (1, 2) -
}
int somefunc (double arg1, arg2 int)
{
// ...faça alguma coisa
}

A declaração protótipo diz ao mundo (pelo menos a parte do mundo após a declaração), que o nome estendido para somefunc () é someFunction (double, int). A chamada em a Principal() agora sabe para lançar o 1 a um casal antes de fazer a chamada. Além, a Principal() sabe que o valor devolvido pela somefunc () é um int.

A chamada de função que retorna um valor é um expressão. Tal como acontece com qualquer outra expressão fornecer, você tem permissão para lançar o valor retornado por uma função.

tipos de armazenamento de variáveis

variáveis ​​de função são armazenadas em três locais diferentes. Variáveis ​​declaradas dentro de uma função são disse a ser local. No exemplo a seguir, a variável LocalVariable é local para a função fn ():

int globalVariable-
fn void ()
{
int localVariable-
static int staticVariable-
}

a variável LocalVariable não existe até que a função fn () é chamado. LocalVariable deixa de existir quando a função retorna. Ao retornar, seja qual for o valor que é armazenado no LocalVariable está perdido. Além disso, apenas fn () tem acesso aos LocalVariable - outras funções não pode chegar para a função de acessá-lo.

Por comparação, a variável GLOBALVarißvel existe enquanto o programa está em execução. Todas as funções têm acesso a GLOBALVarißvel todo o tempo.

A variável estática staticVariable é uma espécie de mistura entre um local e uma variável global. a variável staticVariable é criado quando a execução atinge primeiro a declaração (grosso modo, quando a função fn () é chamado). Além, staticVariable apenas está acessível fn (). Ao contrário LocalVariable, Contudo, staticVariable continua a existir mesmo após o programa retorna de fn (). E se fn () atribui um valor para staticVariable uma vez, ele ainda estará lá na próxima vez que fn () é chamado.

No caso de alguém perguntar, há um quarto tipo, auto, mas hoje ele tem o mesmo significado que local, então simplesmente ignorá-los.

» » » » Trabalhando com Funções em C ++