Domande di base per capire il c++

[ubanton]

Ciao a tutti,leggendo alcuni listati, mi trovo prototipi di funzioni scritti in maniera diversa da come è scritto su alcuni libri di testo, ve li posto:

void BubbleSort(Vettore , const int): allora c'è il tipo dei parametri formali, ma non c'è il nome della variabile non sembra strano?

void LeggiElementi(Vettore, int &);
nel main così
LeggiElementi(V,n), ma scusate quando n deve essere passato al parametro formale, ma gli viene passato il valore o l'indirizzo?

int main(void), ma il void dentro il main direbbe di pietro che c'azzecca, non ci dovrebbe essere (int argc, char *argv[])?

differenze tra dichiarazione e definizione(voi direte la definizione porta allocazione in memoria, si ok ma come faccio a distinguerla nel listao da una dichirazione?

per voi saranno tutte semplicissime, però io voglio capire bene.
Grazie a tutti

[[Kendall]]

Andando per ordine:

Ciao a tutti,leggendo alcuni listati, mi trovo prototipi di funzioni scritti in maniera diversa da come è scritto su alcuni libri di testo, ve li posto:

void BubbleSort(Vettore , const int): allora c'è il tipo dei parametri formali, ma non c'è il nome della variabile non sembra strano?

Qui la funzione richiede un tipo Vettore (cioè un tipo definito dall'utente, in parole povere richiede un oggetto della classe Vettore definita dall'utente). Entrambi gli argomenti sono passati per valore, quindi attenzione che nel caso del vettore viene invocato un costruttore per copia.

void LeggiElementi(Vettore, int &);
nel main così
LeggiElementi(V,n), ma scusate quando n deve essere passato al parametro formale, ma gli viene passato il valore o l'indirizzo?

Idem come sopra per quanto riguarda il Vettore, mentre l'intero viene passato per riferimento. Questo significa che non viene eseguita una copia interna del parametro attuale, ma viene utilizzato un suo "alias", quindi ogni modifica al parametro formale modificherà anche il parametro attuale.
L'indirizzo non viene passato, questo succederebbe nel caso in cui la funzione richiedesse un puntatore: void LeggiElementi(Vettore, int*);
E la chiamata sarebbe così: LeggiElementi(V, &n).
(Attenzione a non confondere l' "&" anteposto (che serve appunto ad estrarre l'indirizzo della variabile, all' "&" posposto (che indica invece, come già visto, un riferimento a variabile).

int main(void), ma il void dentro il main direbbe di pietro che c'azzecca, non ci dovrebbe essere (int argc, char *argv[])?

Quella è una delle versioni della funzione main accettate dal compilatore. Analoga alla forma int main(). Se il main viene utilizzato in questa forma ovviamente non può utilizzare i parametri argc e argv (che contengono informazioni sul percorso dell'eseguibile e su eventuali altri parametri specificati durante l'esecuzione dell'eseguibile).


differenze tra dichiarazione e definizione(voi direte la definizione porta allocazione in memoria, si ok ma come faccio a distinguerla nel listao da una dichirazione?

per voi saranno tutte semplicissime, però io voglio capire bene.
Grazie a tutti
Le dichiarazioni devono sempre comparire prima delle chiamate alle funzioni stesse (le direttive di "include" per esempio hanno proprio lo scopo di inserire tutte le dichiarazioni di un header all'interno del file che stai scrivendo, in maniera tale da poter usare quelle funzioni o quelle classi).
La differenza tra dichiarazione e definizione, a livello di forma, è che la dichiarazione è solo una traccia di quella che sarà poi la definzione, e quindi deve contenere solo il nome della funzione e tipi degli argomenti formali e dell'argomento restituito (è permesso comunque inserire dei nomi per gli argomenti formali, e secondo me è pure consigliabile in quanto è una sorta di autodocumentazione della funzione).
La dichiarazione è il solo prototipo, tanto che viene conclusa con un semplice ";" dopo il prototipo stesso (a parte il caso delle funzioni inline, ma per ora lasciale stare), mentre le definizioni riportano l'intero corpo di istruzioni che indicano quello che effettivamente le funzioni fanno (le definizioni, in parole povere, contengono sempre l'implementazione di una funzione. Quindi, se un prototipo è seguito da un blocco di istruzioni sai già che è una defizione di funzione, se invece tale corpo non c'è e il prototipo si conclude con il punto e virgola allora sai già che è solo una dichiarazione.

Ultimo appunto: quando utilizzi una funzione basta avere la sola dichiarazione nel file che stai scrivendo. Le definzioni sono implicitamente "extern" quindi il compilatore andrà a cercarsi autonomamente una definizione adeguata sui vari file che compongono il progetto.


Spero di non averti fatto più confusione che altro! :-P

[pabloski]

void BubbleSort(Vettore , const int): allora c'è il tipo dei parametri formali, ma non c'è il nome della variabile non sembra strano?


è normale, non devi mica specificare per forza il nome del parametro nel prototipo

è nell'implementazione della funzione che deve comparire necessariamente il nome del parametro


void LeggiElementi(Vettore, int &);
nel main così
LeggiElementi(V,n), ma scusate quando n deve essere passato al parametro formale, ma gli viene passato il valore o l'indirizzo?


si, ma il passaggio dell'indirizzo nel c++ è implicito

se in C avresti scritto LeggiElementi(V,&n) in C++ scriverai LeggiElementi(V,n)

e i prototipi sono LeggiElementi(Vettore, int*) e LeggiElementi(Vettore, int&)

perchè in C++ si ampio uso dei riferimenti, mentre in C non esistono


int main(void), ma il void dentro il main direbbe di pietro che c'azzecca, non ci dovrebbe essere (int argc, char *argv[])?


non necessariamente, in C e C++ la main risponde ad uno dei seguenti prototipi


int main(void)

int main(int argc, char **argv)
int main(int argc, char *argv[])

int main()



differenze tra dichiarazione e definizione(voi direte la definizione porta allocazione in memoria, si ok ma come faccio a distinguerla nel listao da una dichirazione?


nella dichiarazione stai semplicemente avvisando il compilatore che esiste un oggetto fatto in un certo modo

ad esempio


void pippo(int n);



nella definizione invece implementi le funzioni ( cioè ci metti il codice )

la dichiarazione corrisponde al prototipo della funzione ( quello che vedi nei file .h per intenderci )

[ubanton]

ragazzi vorrei chiedervi delle spiegazioni su questo:(non posto tutto il codice altrimenti diventa infinito)

bool Cerca_Prodotto(const Magazzino M, const int n, const char * C, int & pos){

bool trovato=false;
int i=0;
pos=-1;

cout <<"Trovato intermedio: "<<trovato<<endl;
cout <<"i vale: "<<i<<endl;
while(i<n && !trovato)

if(!strcmp(M[i].Codice,C)) {
cout <<"Trovato prima: "<<trovato<<endl;
pos=i;
trovato=true;
cout <<"Trovato dopo: "<<trovato<<endl;
}
else i++;
return trovato;
}

questo il main.cpp

#include <cstdlib>
#include <iostream>

#include "Prodotti1.h"

using namespace std;

int main(int argc, char *argv[])
{
// Test delle funzioni sul tipo prodotto
Prodotto P1;
Inserisci_DatiProdotto(P1);
Visualizza_DatiProdotto(P1);
// ********** FINE *********************

// Inizio programma
Magazzino M;
int n;

// PARTE 1
Crea_Magazzino(M,n);
Visualizza_Magazzino(M,n);
system("PAUSE");

// PARTE 2
char C[DIM];
int pos=-1;
cout << "\n Ricerca Prodotto.";
cout << "\n Inserire il Codice: ";
cin.ignore();
cin.getline(C,DIM);
if(Cerca_Prodotto(M,n,C,pos)) cout << "\n Prodotto presente. Posizione: " << pos;
else cout << "\n Prodotto NON presente." ;
system("PAUSE");


vorrei sapere nella specifica della funzione Cerca_Prodotto, !trovato che significa(io penserei trovato==false) e perchè usa !strcmp per fare il confronto, cioè lui dovrebbe fare il confronto se strcmp torna 0 dovrebbe entrare nel ciclo if, ho molti dubbi nel capirlo.
Aspetto il vostro aiuto. Grazie