Visual C++ permet mantenir una estructura complexa d'espais de treball, projectes i arxius. Es proposa per tot el curs que cada mòdul diferent correspongui a un nou espai de treball, i cada pràctica o exercici correspongui a un nou projecte. Tots els projectes tindran, doncs, un únic arxiu. Els projectes del Tema 1 es posaran en un espai de treball anomenat T1, els del Tema 2 a l'espai de treball T2 i així successivament.
Per tant, el primer que s'ha de fer és crear un nou espai de treball en blanc i anomenar-lo T6_Arrays, per això s'han de seguir els següents passos:
Per tal de crear un nou espai de treball seleccioneu en el menú: File->New->fitxa Workspaces, Blank Workspace. Trieu el directori on es posaran tots els arxius (es recomana el directori c:\PLE). Ompliu amb el nom d'aquest directori el camp Location i poseu el nom T6_Arrays en el camp Workspace name.
Ara que ja tenim un espai de treball nou crearem un nou projecte:
Feu clic amb el botó dret del ratolí damunt el text: Workspace 'T5_Funcions 0 projects i seleccioneu l'opció Add New Project to Workspace. Seleccioneu l'opció Win32 Console Application. D'aquesta forma podreu veure el quadre de diàleg de la figura:
Ompliu els camps: Project name i Location amb el nom del projecte i la seva ubicació. El quadre del camp Location afegeix automàticament una barra invertida, seguida del nom del projecte inserit en el quadre del camp Project name.
Anomeneu el projecte 10_Parells. Deixeu activat l'opció Add to current workspace i Platforms: Win32 i feu clic en OK.
Apareixerà un quadre de diàleg amb el títol Win32 Console Application -Step 1 of 1. Deixeu activada l'opció An empty project i feu clic en Finish.
Apareix una altre quadre de text: New Project Information amb la informació d'allò que ha construït l'assistent Win32 Console Application. En aquest cas, no ha creat cap arxiu. Feu clic en OK.
Ara que ja tenim un projecte anomenat 1Vector un espai de treball anomenat Tema6_Arrays, hem d'afegir un nou arxiu al projecte on escriurem el codi font de l'aplicació. Seleccioneu File -> New->fitxa Files ->C++ Source File. Deixeu activada l'opció Add to project 10_Parellsi ompliu el camp File name amb el nom 10_Parells. Visual C++ afegeix automàticament l'extensió ".cpp". Feu clic a OK.
#include<stdio.h>
void main(){
int v[5],i;
for(i=0;i<5;i++) scanf("%d",&v[i]);//llig el vector
for(i=0;i<5;i++) printf("\t%d",v[i]);//escriu el vector
}
Ara crearem l'arxiu 1Vector.exe: Seleccionem Build -> Build Tema6_Arraysp01.exe (o bé la tecla F7). D'aquesta forma es crearà un arxiu anomenat 1Vector.exe a la carpeta \...\10_Parells\debug\.
Seleccioneu Build->Execute 10_Parells.exe (o bé la tecla Ctrl F5).
Si ens fixem en la mida de l'arxiu executable veurem que és massa gran (més de 150 kb). Aquest arxiu tan gran permet la depuració o correcció d'errors (debug). El tema de la depuració serà tractat més endavant. Si ja hem comprovat que el programa funciona, podem fer una compilació optimitzada que crearà un arxiu executable més petit.
Seleccioneu Build ->Clean. Això esborrarà tots els arxius de la carpeta \...\10_Parells\debug\, incloent l'arxiu 10_Parells.exe.
Seleccioneu Build ->Set Active Configuration ->Tema6_Arraysp01: Win21 Release i feu clic a OK.
Torneu a construir l'arxiu pract1.exe amb Build -> Build 10_Parells.exe i veureu que aquesta vegada ha construït l'arxiu 10_Parells.exe a la carpeta \...\10_Parells\release\ amb una mida sensiblement més petita.
Podem comprovar que aquest és un arxiu executable de consola executant-lo en una finestra MS-DOS fora de l'entorn de Visual C++. Això es pot fer des del Windows 95/98/2000 amb inici->Programes->MSDOS. Una vegada en la finestra, podem desplaçar-nos per les diferents carpetes del disc amb el comandament MS-DOS:
- cd <nom de carpeta> per anar a una carpeta filla específica.
- cd .. per anar a la carpeta mare.
Una vegada a la carpeta \...\10_Parells\release\ proveu d'escriure 10_Parells(no fa falta escriure el nom de l'extensió).
Abans de produir la versió definitiva d'un programa hem de procurar que aquest estigui lliure d’errors. En el moment de la compilació, el compilador ens pot avisar d’alguns errors de sintaxi, confusió de tipus, etc. Aquests errors que pot detectar el compilador s’anomenen errors de compilació, i gairebé sempre són fàcils de detectar.
Si per al compilador la sintaxi del programa és correcta, però aquest no fa exactament el que hauria de fer, pot ser degut, segurament, a un error lògic o error d’execució. Aquests tipus d'errors són els realment difícils de detectar. Per ajudar a detectar-los es fa servir un dels elements més valuosos de l’entorn Visual C++, el depurador o debuger.
Ja hem parlat al primer mòdul, que el Visual C++ pot crear diferents versions d’un programa executable. Fonamentalment hi ha dos tipus de versions: la versió Release (preparada per a la publicació) i la versió Debug (preparada per a la depuració).
La versió Release és una versió optimitzada. Aquesta versió és ràpida i ocupa poc espai. La versió Debug conté informació necessària per tal de permetre la depuració, això sí, a costa de fer executables llargs i lents.
El procediment habitual és produir sempre programes amb la versió Debug en les fases de desenvolupament fins que ens assegurem que no hi ha errors (cosa que mai es pot assegurar 100%), una vegada que el programa s’ha provat i funciona correctament, ja es pot esborrar la versió Debug i produir la versió Release.
La selecció d’una o altra versió es fa abans de la compilació. Si la barra d’eines Build és visible, es pot observar a la part superior d’aquesta barra un quadre combinat amb la qual es pot seleccionar una o altra opció. També es pot canviar de configuració des del menú Build ->set active configuration.
Errors i advertiments de compilació
Una vegada acabada l'escriptura del codi del programa es construeix l'aplicació. Ja havíem mencionat que aquesta tasca es pot fer directament amb l'opció build (F7) o en dos passos: compile i build. En qualsevol cas, tots els errors detectats pel compilador, així com altres advertiments, es mostren a la finestra de sortida (Output), particularment a la pestanya Build d'aquesta finestra.
El compilador ens pot donar dos tipus de missatges: els errors i els advertiments (warnings).
Un error impedeix la construcció de l'executable. El compilador ens informa del tipus d'error i la línia en la qual es produeix l'error. S'ha de tenir en compte que no tots els errors són independents, això vol dir que és probable que un mateix error produeixi més d'un missatge d'error, per exemple, si no declarem una variable, el compilador detectarà un error cada vegada que aparegui en el codi aquesta variable.
Els errors més freqüents que es sol cometre i que detecta el compilador són:
A més d'aquests errors que obliguen a corregir el codi i tornar a compilar o construir l'aplicació, el compilador ens avisa d'algunes circumstàncies que, encara que no impedeixen la construcció de l'aplicació, poden ser errors que s'han de corregir. Per exemple, el compilador ens avisarà si:
Si tot a anat bé i el compilador ha fet la seva tasca sense detectar cap error, ja s'ha creat el fitxer executable, aquest fitxer, si s'ha creat amb la versió DEBUG, es pot provar amb eines que permeten detectar comportaments no desitjats.
Depuració
Per tal de fer servir el depurador o debug hem de seleccionar l'opció Go (F5). Això permet fer que el programa s'executi fins a un punt determinat i, a partir d'aquest moment, el depurador pren el comandament de l'execució. Si premem F5 o seleccionem GO abans de compilar o construir el programa, primer es compila i es construeix l'aplicació i després s'executa.
Per forçar que el programa s'aturi en un punt determinat del codi hem de col·locar un punt de ruptura o breakpoint. Es poden col·locar tots els punts de ruptura que s'estimi necessaris. La forma més ràpida de col·locar un punt de ruptura és prement la tecla F9 quan el cursor està sobre la línia desitjada. Això farà que al començament de la línia aparegui un punt vermell. La tecla F9 actua com un commutador, és a dir, si premem F9 damunt d'una línia marcada, la marca desapareix.
Quan l'execució del codi s'atura perquè ha trobat un punt de ruptura, l'opció Buid del menú es substitueix per l'opció Debug , que conté, entre altres, opcions per poder executar el programa pas per pas.
Una aplicació usual dels punts de ruptura consisteix en comprovar si s'està executant una part determinada del codi, per exemple, la part interior d'un bucle. Si es col·loca un punt de ruptura en un punt del codi i l'execució no s'atura vol dir que el programa no arriba a passar per aquest punt.
Una vegada seleccionada l'opció GO, si es troba un punt de ruptura, l'execució s'atura. En aquest moment podem observar el valor actual de les variables, per això hi ha diverses formes:
situant el cursor damunt el nom d'una variable apareix un quadre amb el valor actual d'aquesta variable.
escrivint el nom de la variable desitjada a la finestra WATCH. Aquesta finestra s'activa automàticament en la depuració.
La finestra WATCH té dues columnes, a la primera columna podem escriure el nom d'una variable o expressió. En la segona columna apareix automàticament el seu valor en aquest punt del programa. Es pot modificar els valors de les variables no constants que es mostrin en aquesta finestra.
Com gairebé tots els llenguatges de programació, C incorpora en la seva llibreria estàndard una funció que genera un nombre pseudoaleatori. En el cas concret del C, aquest nombre és un enter comprès entre 0 i 32.767. El prototipus d'aquesta funció és:
int rand()
i per tal de fer-la servir s'ha d'incloure el fitxer de capçalera stdlib.h.
Altres llenguatges de programació incorporen també una funció similar. Normalment és una funció que genera un nombre real de l'interval [0, 1). Aquesta funció és més útil en molts casos.
Per tal de generar en C un nombre real entre 0 i 1 (incloent el 0 i excloent l'1) podem fer servir l'expressió:
(float) rand()/32768
Per tal de generar un nombre real entre 0 i n ( [0,n) ) es fa servir l'expressió:
(float) rand()*n/32768
De fet, aquesta expressió, com l'anterior, generarà un nombre real d'entre 32768 nombres reals compresos entre 0 i n, no seguirà estrictament, per tant, una distribució uniforme.
Per tal de generar un nombre enter entre 0 i n–1, ambdós inclosos i n<32768, es fa servir l'expressió:
rand()*n /32768
Si n>32768 aquest mètode farà que hi hagi nombres que no es generaran, per exemple, si n/32768 = 2, tots els nombres generats seran parells. Aquest problema es pot solucionar generant dos números aleatoris, per exemple:
rand()*32768+rand()
és un nombre aleatori comprès entre 0 i 1.073.741.824
L'algorisme intern que utilitza la funció rand() fa servir una llavor o valor inicial per iniciar la seqüència de nombres aleatoris. La funció srand() permet assignar un valor nou a aquesta llavor o valor inicial.