C++/Ola mundo

C++
	Ola mundo

A mellor maneira de comezar a aprendizaxe de C++ é co seguinte programiña:

// Pequeno programa que imprime a mensaxe «Ola mundo!».
#include <iostream>

int main()
{
  std::cout << "Ola mundo!" << std::endl;
  return 0;
}

Malia a simplicidade do programa, cómpre que antes de continuar a aprendizaxe da linguaxe, compile e execute o programa. Debería imprimir no terminal dende o que o execute o seguinte texto:

Ola mundo!

Se ten algún problema para compilalo, consúlteo con calquera programador de C++. Pode mesmo empregar a páxina de discusión deste capítulo. A continuación explicarase parte por parte o programa.

O comentario

A primeira liña do programa contén o seguinte:

// Pequeno programa que imprime a mensaxe «Ola mundo!».

Os caracteres // indican o comezo dun comentario, que afecta a todo o que conteña a liña á dereita deles. Os comentarios son ignorados polo compilador, e o seu propósito consiste en permitirlle ao programador explicar o código para que outros programadores poidan comprendelo con maior facilidade.

O #include

En C++, moitas das funcionalidades fundamentais, como a entrada e saída de datos, forman parte da biblioteca estándar, non do núcleo da linguaxe. Isto resulta importante porque o núcleo da linguaxe está dispoñible para todos os programas de C++, pero hai que indicar as partes da biblioteca estándar que se queren empregar .

Os programas solicitan funcionalidades da biblioteca estándar mediante directrices #include. Estas adoitan listarse ao principio do programa. O noso programa só emprega a parte da biblioteca estándar correspondente á entrada e saída de datos, que solicitamos mediante a seguinte liña de código:

#include <iostream>

O nome «iostream» fai referencia á entrada e saída secuencial ou de fluxo (stream), en contraposición a outras partes da biblioteca coma o acceso aleatorio ou a entrada e saída gráfica. Como «iostream» aparece na directriz #include e vai entre os caracteres «<» e «>», fai referencia a unha parte da biblioteca estándar chamada “cabeceira estándar” (standard header). Incluír a cabeceira estándar pon as funcionalidades das bibliotecas asociadas a disposición do programa.

A función principal

Unha función é un anaco de programa que ten nome, e que outra parte do programa pode chamar, facendo que se execute. Todo programa en C++ debe conter unha función chamada «main». Ao executarse o programa, será esta a función que se execute.

A función principal ten que devolver un valor enteiro. Este valor indicará se o programa se executou correctamente ou, de haber algún erro, para indicar o tipo de erro.

Por iso, comezamos a parte executable do programa coa seguinte liña de código:

int main()

Con isto indicamos que estamos a definir unha función chamada «main» que devolve un valor de tipo «int». «int» é a palabra que emprega o núcleo da linguaxe para facer referencia aos números enteiros. A parella de parénteses a continuación de «main» contén a lista de parámetros que a función recibe. Neste exemplo concreto, a función non recibe ningún parámetro. Porén, a función principal pode recibir parámetros, como se verá máis adiante.

As chaves

A definición da función principal continúa seguindo aos parénteses unha secuencia de sentenzas delimitadas por unha parella de chaves.

int main()
{	// Chave inicial.
	// Sentenzas.
}	// Chave final.

En C++, as chaves indican que o que vaia entre elas debe tratarse coma unha unidade. No noso exemplo, a chave inicial indica o inicio da función principal e a final indica, evidentemente, o seu final. Noutras palabras, as chaves indican que todo o que vai entre elas forma parte da mesma función.

Cando hai dous ou máis sentenzas entre as chaves, estas executaranse na orde en que aparecen.

Empregando a biblioteca estándar para a saída de datos

A primeira liña de código do programa é a que fai o verdadeiro traballo:

std::cout << "Ola mundo!" << std::endl;

Esta sentenza emprega o operador estándar de saída, «<<», para escribir «Ola mundo!» na saída estándar, e logo o valor de «std::endl».

Prefixar un nome con «std::» indica que o nome forma parte do espazo «std». Un espazo é unha colección de nomes relacionados entre si. A biblioteca estándar emprega «std» para conter todos os nomes que define. Por exemplo, a cabeceira estándar de «iostream» define os nomes «cout» e «endl», e facemos referencia a eles como «std::cout» e «std::endl».

O nome «std::cout» fai referencia ao fluxo de saída estándar, que será o que o sistema poña a disposición do programa para imprimir os datos de saída ordinarios do programa. Por exemplo, se o programa se executa dende un terminal, o propio terminal será a saída estándar.

Escribir o valor de «std::endl» remata a liña actual de saída, de xeito que se o programa volve escribir algo máis na saída estándar, estes novos datos aparecerían nunha nova liña.

O return

A sentenza de devolución pon fin á execución da función na que aparece, e pásalle o valor entre a palabra clave «return» e o punto e coma («;») á función que chamou á función da que se executa a sentenza. O tipo de dato devolto debe ir acorde ao que a función indica que vai devolver na súa definición.

No caso da función principal, o tipo de devolución é «int», e a función que a chamou é o propio sistema operativo. Polo tanto, a sentenza de devolución da función principal debe incluír un valor enteiro, que se lle devolverá ao sistema.

Por suposto, pode que haxa varias partes dunha función nas que cómpre rematar a execución do programa. Un programa pode ter para iso varias sentenzas de devolución. Pero todas elas deben devolver un valor do tipo definido para a función na que aparecen.

Afondando

No programa reflíctense dous conceptos adicionais de C++: expresións e ámbito. Se ben non fai falla afondar nestes conceptos, si que cómpre introducilos.

As expresións

As expresións requiren que se procese algo. O procesamento remata cun resultado, e pode ter ademais efectos colaterais —podería afectar ao estado do programa de modos que non teñen por que estar directamente ligados ao resultado—. Por exemplo, «3+4» é unha expresión cuxo resultado é «7», e que non ten efectos colaterais. Por outra banda, a seguinte liña de código (que empregamos no programa) é unha expresión que ten como efecto colateral que se imprima en pantalla o texto «Ola mundo!» e un salto de liña:

std::cout << "Ola mundo!" << std::endl;

As expresións conteñen operadores e operandos, e ambos os dous poden ter diversas formas. Na expresión anterior, «<<» é un operador, e «std::cout», «"Ola mundo!"» e «std::endl» son operandos.

Todo operando ten un tipo. Un tipo consiste basicamente nunha estrutura de datos e mailos operadores que cobran sentido para esa estrutura. O efecto dun operador depende do tipo dos operandos.

Os tipos adoitan ter nome. Por exemplo, o núcleo da linguaxe define «int» como o nome do tipo que representa enteiros, e a biblioteca define «std::ostream» como o tipo que fornece saída en fluxo. No programa, «std::cout» é do tipo «std::ostream».

O operador «<<» precisa de dous operandos, pero no programa empregamos dous operadores e tres operandos. Como? A resposta é que «<<» é asociativo pola esquerda, o que en poucas palabras significa que cando aparece varias veces nunha mesma expresión, cada «<<» empregará canto poida do seu operando pola esquerda, e o mínimo do seu operando pola dereita. No noso programa, o primeiro operador «<<» ten «"Ola mundo!"» como operando pola dereita e «std::cout» como operando pola esquerda, e o segundo operador «<<» ten «std::endl» como o seu operando pola dereita e «std::cout << "Ola mundo!"» como o seu operando pola esquerda.

Pero isto podémolo clarificar facilmente. A seguinte sentenza é equivalente á anterior, pero con parénteses para facer máis evidente a prioridade de procesamento.

( std::cout << "Ola mundo!" ) << std::endl;

Cada «<<» se comporta dun xeito dependendo do tipo de dato dos seus operandos. O primeiro «<<» ten como operando pola esquerda «std::cout», de tipo «std::ostream». O seu operando pola dereita é unha cadea de texto literal, cuxo tipo de dato non discutiremos agora. Con eses tipos de dato nos seus operandos, «<<» escribe os caracteres do seu operando pola dereita no fluxo ao que fai referencia o seu operando pola esquerda, e o seu resultado é o seu operando pola esquerda.

É dicir, despois de executarse a liña anterior, é como se a expresión quedase coa seguinte forma:

std::cout << std::endl;

O operando pola esquerda do segundo «<<» é unha expresión que devolve «std::cout», que ten por tipo «std::ostream». O operando pola dereita é «std::endl», que é un manipulador. A propiedade clave dos manipuladores é que escribir un nun fluxo manipula o fluxo, facendo algo distinto a escribir nel un carácter. Cando o operador pola esquerda de «<<» é de tipo «std::ostream» e o operador pola dereita é un manipulador, «<<» faille ao fluxo o que diga o manipulador, e devolve o fluxo como resultado. No caso de «std::endl», a acción consiste en poñerlle fin á liña actual de saída.

Polo tanto, a expresión (toda ela) ten por resultado «std::cout» e, como efecto colateral, escribe «Ola mundo!» no fluxo de saída estándar e ponlle fin á liña de saída. Logo, ao escribir un punto e coma («;») a continuación da expresión, estamos dicindo que o valor devolto pode descartarse, dado que no que estabamos interesados era nos seus efectos colaterais.

Os ámbitos

O ámbito dun nome é a parte do programa na que ese nome ten significado. C++ ten moitos tipos distintos de ámbitos, e neste programa vimos dous deles.

O primeiro ámbito que empregamos foi un espazo, que como xa dixemos consiste nun conxunto de nomes relacionados entre si. A biblioteca estándar define todos os seus nomes no espazo «std», para evitar conflitos con nomes definidos por nós —sempre e cando non sexamos tan parvos como para definir «std»—. Ao empregarmos un nome da biblioteca estándar, debemos indicar que o nome que queremos é o da biblioteca. Por exemplo, «std::cout» significa «o nome “cout” que está no ámbito (espazo) “std”».

As chaves son outro tipo de ámbito. O corpo da función principal, así coma o de calquera outra función, é un ámbito en si mesmo. Este feito non resulta relevante para un programa tan pequeno coma este, pero resultará fundamental con programas de maior magnitude.

C++
	Ola mundo