C/Funcións: Diferenzas entre revisións
Contido eliminado Contido engadido
mSen resumo de edición |
Revisado e completado coa información de «Función principal». |
||
Liña 1:
{{Navegador|
Un programa en C está formado pola [[{{PAGENAME}}#A función principal|función principal]] (o código que se executa ao chamar ao programa) e, xeralmente, outras funcións, xa formen parte da [[{{BASEPAGENAME}}#Biblioteca estándar|biblioteca estándar de funcións de C]] ou sexan funcións escritas polo propio usuario.
As funcións son fragmentos de código que poden chamarse en calquera parte do código da función principal ou doutra función. As funcións realizan unha serie de tarefas a partir dun ou varios datos que reciben como argumentos, e como resultado desas tarefas as funcións devolven un valor (opcionalmente).
==Compoñentes das funcións==
As funcións en C están baseadas en tres compoñentes: [[{{PAGENAME}}#Definición dunha función|definición]], [[{{PAGENAME}}#Declaración dunha función|declaración]] e [[{{PAGENAME}}#Chamada a unha función|chamada]]. Destes tres compoñentes, só un deles é estritamente necesario para que a función forme realmente parte do código fonte: a definición. Esta é a parte que describe o funcionamento da función. Cando nunha parte do código queremos que se faga a tarefa para a que a función se creou, chámase a dita función para que faga dita tarefa. E a declaración da función só é unha presentación da mesma, un xeito de que o compilador coñeza a función en caso de que se atope cunha chamada á mesma antes de dar coa súa definición.
Así e todo, o máis habitual é atoparse
===Definición dunha función===
A definición de unha función é a función en si mesma. É un algoritmo que pode recibir un valor, varios valores ou mesmo ningún valor, e que
A definición dunha función consta de dúas partes ben diferenciadas: a cabeceira e o corpo.
A '''cabeceira''' consta de tres partes ben diferenciadas: (1) o tipo de dato de saída, (2) o identificador único ou nome da función e (3) os tipos de dato e identificadores das variables
O '''corpo''' da función
A sintaxe fundamental da definición dunha función sería a seguinte:
<source lang="c">
tipodesaída identificador(tipo1 variable1, tipo2 variable2, ..., tipon variablen){ // Cabeceira
int main (void) // Cabeceira▼
// Instrucións que conforman a función.
// As variables cos datos cos que se chama á función
// definidas na cabeceira poden usarse libremente.
}
</source>
Un exemplo de definición dunha función podería ser o seguinte:
<source lang=c>
▲A '''cabeceira''' consta de tres partes ben diferenciadas: (1) o tipo de dato de saída, (2) o identificador único ou nome da función e (3) os tipos de dato das variables que se van recibir.
signed int Produto(signed int operando1, signed int operando2){
signed int resultado;
resultado = operando1 * operando2;
return resultado; // O seu tipo debería coincidir co tipo de
// saída definido na cabeceira.
}
</source>
===Chamada a unha función===
▲Na terceira parte, salvo para o caso en que non se reciban datos (<code>void</code>), os tipos de datos deben estar ligados ao nome dunha variable que terá "xurisdición" dentro do bloque da función. Isto é coma unha declaración de variables corrente, sendo a única diferencia respecto ás outras declaracións de variables que a variable se ''inicializa'' cun valor que se lle fornece na [[{{PAGENAME}}#Chamada a unha función|chamada á función]], que se realiza dende outra función.
A sintaxe fundamental da chamada a unha función sería a seguinte:
<source lang=c>
▲O '''corpo''' da función compono o bloque de sentencias que segue á [[{{PAGENAME}}#Cabeceira|cabeceira]].
variablecalquera = identificador(valor1, valor2, ..., valorn);
</source>
<source lang=c>
▲Mediante a chamada a unha función, o programa realiza os procesos contidos na definición de dita función. As funcións poden recibir ou non datos, variables, e asemade poden devolver (ou non) un dato como resultado dos procesos contidos na definición da función.
resultadode3por5 = Produto(3, 5);
</source>
====Paso por valor e paso por referencia====▼
▲===Paso por valor e paso por referencia===
Á hora de pasarlle a unha función unha variable como argumento, pódese facer de dous xeitos: paso por valor, ou paso por referencia.
O caso máis común é o paso por valor. Neste caso, o que se lle pasa á función é o valor que contén a variable. Para pasarlle unha variable a unha función por valor, abonda con escribir o identificador da función. Ao executarse a función, esta crea unha nova variable cuxo identificador queda definido na [[{{PAGENAME}}#Definición dunha función|definición da función]], e ''inicialízaa'' co valor da variable que se lle
Porén, tamén
<source lang=c>
funcion1(variable); // Aquí prodúcese un paso por valor.
Liña 47 ⟶ 64:
</source>
===Declaración dunha función===
A declaración ou prototipo dunha función precísase para que cando o compilador chegue á chamada dunha función antes de chegar á definición da mesma, este xa saiba da súa existencia e coñeza:
*
*
*
Isto quere dicir que, en caso de que a definición da función vaia ''antes'' das chamadas á mesma, non sería preciso incluír a declaración da función. De todos xeitos, é costume que a primeira función que apareza no código fonte sexa a principal, e a primeira función adoita ser a que contén a meirande parte das chamadas a funcións, polo que situar as declaracións
A declaración dunha función ten que aparecer entre as [[{{BASEPAGENAME}}/Directrices para o
As partes de que consta
Velaquí uns exemplos de declaracións dunha función:
Liña 64 ⟶ 81:
int IdentificadorDaFuncion2(double, double) // Esta non, simplemente leva os tipos de datos que vai recibir na chamada
</source>
==A función principal==
A función principal é fundamental, e representa o punto de inicio da execución dun programa. A súa sintaxe fundamental é a seguinte:
<source lang=c>
// Instrucións que conforman o programa.
}
</source>
===Argumentos da función principal===
Cando se executa un programa, a función recibe do sistema dous parámetros: un contador de argumentos e unha lista de argumentos.
O contador de argumentos adoita nomearse '''<code>argc</code>''', abreviatura de ''argument count'', «conta de argumentos». Trátase dun número enteiro que representa a cantidade de valores que se lle pasan ao programa antes de que comece a súa execución.
A lista de argumentos adoita denominarse '''<code>argv</code>''', abreviatura de ''argument vector'', «matriz de argumentos». É un punteiro a unha matriz de cadeas de caracteres de distintas lonxitudes. Cada unha destas cadeas conterá cada un dos argumentos que se fornezan na chamada ao programa.
Visto isto, a seguinte sería a declaración estándar da función principal naqueles programas que reciban argumentos:
<source lang=c>
int main(int argc, char * argv[]){
// Instrucións que conforman o programa.
}
</source>
Por convención, <code>argv[0]</code> conterá o nome co que se chamou ao executable (xeralmente será a ruta completa do ficheiro executable). Este valor fornéceo automaticamente o sistema operativo, polo que o valor mínimo de <code>argc</code> será un. O resto de celas da matriz conterán os argumentos cos que se chamou ao programa.
Xeralmente <code>argc</code> utilízase para controlar os argumentos fornecidos polo usuario ao chamar ao programa, xeralmente rematando a súa execución, non sen antes indicarlle ao usuario a forma correcta de chamar á función.
{{Navegador|
<!-- Categorías: -->
[[Categoría:C ─
| |||