Quando sono mancato la prof. ha spiegato le matrici e leggendo quell'infimissimo libro ho capito ben poco... è tipo un vettore, ma...?
Visualizzazione Stampabile
Quando sono mancato la prof. ha spiegato le matrici e leggendo quell'infimissimo libro ho capito ben poco... è tipo un vettore, ma...?
E' un vettore di vettori :sisi:, tipo ad esempio
int matrice[][] = {{1,2,3,4,5},{1,2,3,4,5},poi per scorrere la matrice usi due cicli for annidati, ad esempio:
{1,2,3,4,5}};
for(int i=0; i<matrice.size(); i++) {
for(int j=0; j<matrice.size() j++) {
printf(...matice[i][j]..);
}
}
semplice, ovviamente il codice è messo lì da esempio ma il concetto alla fine è quello :sisi:
vai alla voce "multidimensional arrays"
http://www.cplusplus.com/doc/tutorial/arrays/
Si, credo si possa scrivere
for(.......)for(....)printfl(...)
ma io uso sempre le graffe, anche per una sola istruzione, sono abituato così e quando lavori con progetti dalle medie dimensioni in su molte volte una chiara indentazione del codice ti salva la vita :sisi:, e comunque le graffe me le mette l'IDE in automatico :asd:
Occhio:
Fixed.
Dire "vettore di vettori" per quanto possa sembrare corretto e' in realta' senmanticamente una cosa diversa.
Anche il codice d'esempio e' contiene un errore: L'operatore size() non esiste nei vettori "normali" in C/C++, ma solo nei contenitori STL. Indipercui il ciclo che hai scritto non compila. In casi come quello del suo esempio, quando cioe' la dimensione della matrice e' nota, si usano un paio di #define per creare delle costanti simboliche che rapresentano la dimensione della matrice e le si usano nella definizione e nella giardia die cicli for.
L'esempio corretto e quindi questo:
:sisi:
THIS.
L'uso delle graffe e' obbligatorio solo se il blocco di codice da eseguire nel ciclo/costrutto condizionale contiene piu' di una istruzione, ma e' un OTTIMA regola usarlo sempre e comunque, anche solo per aumentare la chiarezza del codice.
:asd:
Diciamo anche che tendo a fare esempi in pseudo codice misto C++/Java/Haskell per sintetizzare la cosa, poi certi particolari li ritengo ovvi a seconda del linguaggio usato e non li scrivo, però in effetti il ragazzo qua sopra magari ha proprio appena cominciato e rischia solo di confondersi le idee :asd:
Ragazzi mi siete stati davvero utili. Nonostante sia mancato alla spiegazione in classe sono uno di quelli che sa usare meglio di tutti le matrici :asd: Mi prendono per pazzo perché vado direttamente in codifica senza diagramma di flusso :bua:
Ora vi volevo porre un'altra domanda... come si utilizza il la selezione casuale dei valori (leggasi random)? La prof. ancora non l'ha spiegato ma caricare anche solo una matrice da 10x10 richiederebbe un botto di tempo... :bua:
Raddoppio la domanda :asd:
Che ha di sbagliato questo programma? :stress:
Spoiler:
Dovrebbe ricercare il massimo della riga e controllare se quest'ultimo è il minimo della colonna...
1) Per generare numeri casuali puoi usare il rand()
http://www.cplusplus.com/reference/c.../rand/?kw=rand
2) Così a prima vista nel secondo ciclo for incrementi ancora "i" al posto di "j"
AH dimenticavo, nell'intestazione dei cicli for c'è un'altro errore abbastanza grave, ma lascio a te il piacere di scoprirlo :fag:
E boh. La prof aveva detto che "forse" era giusto* :bua:
*c'è stata mezz'ora ad interpretarlo e non era neanche sicura
No vabbè, ma cambiate profe, se nemmeno lei si è accorta che i cicli for vanno in overflow siete messi male :bua:
Inoltre a metà programma si utilizza una variabile non inizializzata :sisi:
E perché dovrebbe andare in overflow? :pippotto:
perchè la dimensione degli array che compongono la matrice è 2 mentre il ciclo for fa 3 "giri", gli indici di un array partono sempre da 0 quindi in questo caso sono 0 e 1, mentre nel ciclo la variabile "i" (e j) viene incrementata tre volte in quanto i=0; i<3; ovvero 0,1,2 e quando arriva a 2 va in overflow, va a leggere una cella di memoria che non appartiene all'array :sisi:
Alla fine ho preso 7,5 :asd:
Comunque sono qua per altre delucidazioni. Stavolta si parla di stringhe, in generale e in breve: non so nulla :bua:
ora hai una variabile chiamata "cacca" contenente una cosa che è fondamentalmente un array di caratteri char, e che puoi estrarre e modificare usando appunto un semplice array e il suo indice (es. per accedere alla 'o' di "congratulazioni", useresti voto[1]). Le stringhe sono molto comode. Ovviamente devi utilizzare cstring.h, se la memoria non m'inganna (non programmo da qualche anno, e non sono mai stato su chissà quali livelli).Codice:string compito = "congratulazioni per il voto";
c'è un sito molto utile dove trovare un sacco di informazioni in merito, con tanto di esempi! Here: http://www.cplusplus.com/reference/string/string/
Allora in C le stringhe sono semplicemente vettori di caratteri. Puoi definire una stringa nel seguente modo:
Se non avete studiato ancora i puntatori (e direi che sia cosi' visto l'obbrobrio di prima con le matrici) puoi fare anche cosi':Codice:char* foo = "stringa";
che tanto e' piu' o meno la stessa cosa.Codice:char foo[] = "stringa";
Per convenzione in C le stringhe sono zero-terminated, ossia esse finiscono sempre con un carattere di terminazione che viene spesso indicato come '\0' ad indicare che non e' il codice ascii di zero, ma proprio il valore 0.
In poche parole in C una stringa e' un vettore di caratteri piu' il terminatore \0 in fondo. Nell'esempio che ti ho mostrato la parola 'stringa' ha 7 caratteri, il che significa che il compilatore C creera' un vettore di 8 elementi (7 lettere + il terminatore).
Quindi:
foo[0] vale 's'
foo[1] vale 't'
foo[2] vale 'r'
foo[3] vale 'i'
foo[4] vale 'n'
foo[5] vale 'g'
foo[6] vale 'a'
foo[7] vale '\0'
Dal punto di vista del linguaggio, e' piu' o meno tutto quello che c'e' da dire sulle stringhe. E' un vettore e lo puoi trattare come tutti gli altri vettori. A livello di libreria, c'e' <string.h> (o <cstring>) che ti da accesso a funzioni di manipolazione delle stringhe. Le tre piu' famose sono:
strcpy - Copia una stringa in un'altra
strcmp - Confronta due stringhe
strlen - Ritorna il numero di caratteri della stringa (il terminatore non viene conteggiato)
Tutte queste funzioni assumono che la stringhe terminino correttamente con '\0'.
In C++ queste funzioni non andrebbero usate, visto che c'e' <string> che e' piu' sicura e robusta (e semplice da usare). Ci sono alcuni casi di applicazioni industriali in cui si deve usare per forza la stringa C style, ma in generale sarei sorpreso di trovare ancora le stringhe C in un programma moderno.
Forse ho capito. Forse.
E domani c'è il compito in classe sulle stringhe :lol: Adesso mi uccido tentando di programmare qualcosa di funzionante
Arieccomi! Dopo aver passato il compito precedente in linea con il resto dell'anno (7,5) avrei bisogno di una mano.
Nel programma che ci ha lasciato per casa dato un valore char dobbiamo sostituirlo il carattere che viene 5 volte dopo. Quindi se è A deve diventare F (A+5). Avevo pensato di creare un vettore in char con tutti i caratteri dell'alfabeto e spostarmi in base al confronto prima e incremento dell'indice dopo. Ma non si potrebbe lavorare sul valore ASCII e quindi evitare la creazione del vettore? Per spiegarmi A nel codice ASCII 41, per trovare il valore 5 volte successivo basta fare 41+5. È fattibile come ragionamento?
una somma normale funziona:
ma è inguardabile :bua:Codice:char a = 'a';
printf("\n a=%c\n",a);
int b =(int)a+5;
printf("\n b=%c\n",(char)b);
//output:
a=a
b=f
spero uno che effettivamente sa programmare fornisca una via migliore
edit:anche la mia scelta delle variabile è abbastanza infelice, vabbuò :bua:
Se ho capito bene, dovrebbe bastare leggere in input un char e sommare direttamente 5, e funziona, non ce bisogno di convertire in intero.
Soluzione sotto spoiler
Spoiler:
I char sono interi per definizione quindi si, basta fare una somma, ma attenzione, puoi usare solo i caratteri dell'alfabeto o tutti i caratteri della tabella ascii? Perchè nel primo caso quando arrivi alla quartultima lettera dell'alfabeto (in poi) non devi sommare in quanto sfori negli altri caratteri, quindi sarebbe il caso di usare un array e farti un algoritmino semplice semplice. Se invece puoi usare tutti i caratteri della tabella allora nessun problema, somma e vai con dios :sisi:
EDIT:
Per capirci meglio, devi fare tipo la cifratura di Cesare?
Cosa? :asd:
Comunque no, non posso utilizzare tutti i codici ascii, solo le lettere, ma se è per questo basta fare un calcolo veloce, vedere di quanto sfora e sommare lo sforamento al codice precedente alla A (in modo da ottenere, così, A se sfora di 1 dalla Z ecc...)
Esatto, vedo che hai capito allincircasupergiù:sisi:
Il cifrario di Cesare è questo:
http://it.wikipedia.org/wiki/Cifrario_di_Cesare
In soldoni tu fai lo stesso ma spostandoti di 5 caratteri al posto che di 3 :sisi:
Se l'avessi saputo prima avrei fatto copia-incolla da wikipedia modificando solo qualcosina :asd:
Buonsalve!
Torno sul post per altri dubbi.
Abbiamo iniziato la programmazione ad oggetti, ma dichiarando la classe come file a se e aggiungendola alla libreria nel programma interessato non riesce a trovarmelo, cosa dovrei fare per dire al compilatore che quel file esiste e c'è da qualche parte?
Per ora abbiamo fatto programmi creando la classe proprio sopra al programma, ma così è un po' nosense...
Per fare le cose fatte bene bisogna costruire un makefile ma forse è troppo avanzata come cosa per il momento.
In generale cmq dovresti compilare la classe eseguendo:
g++ -c classe.cpp
Poi il tuo programma:
g++ -c programma.cpp
E poi linkare insieme i due file risultanti dai precedenti comandi:
g++ programma.o classe.o
Il metodo "stupido" è includere il file .cpp invece che il .h nel programma anche se non ci metto la mano sul fuoco che funzioni... non programmo in c++ da un po' purtroppo o per fortuna, gh.
Inviato dal mio Nexus 4
per favorire il riutilizzo del software, è buona norma è separare anche l'interfaccia della classe (contenente le dichiarazioni e i prototipi) dall'implementazione vera e propria (contenente le definizioni). Così otterresti due file: TuaClasse.h (interfaccia) e TuaClasse.cpp (implementazione). Poi nel tuo sorgente principale (quello con la funzione main() ), vai a fare include solo di TuaClasse.h, così:
#include <iostream>
#include "TuaClasse.h" // le " non sono un errore ed è giusto fare così... e devi includerlo anche nel file TuaClasse.cpp, altrimenti il linker non può lavorare
using namespace std;
int main() {blablabla}
esempi presi dall'ottimo manuale Deitel & Deitel 8th edition:
main.cpp:
Codice:// Fig. 3.13: fig03_13.cpp// GradeBook class demonstration after separating
// its interface from its implementation.
#include <iostream>
#include "GradeBook.h" // include definition of class GradeBook
using namespace std;
// function main begins program execution
int main()
{
// create two GradeBook objects
GradeBook gradeBook1( "CS101 Introduction to C++ Programming", "Lt. Spalman" );
GradeBook gradeBook2( "CS102 Data Structures in C++", "Lt. Focaccia" );
// display initial value of courseName for each GradeBook
cout << "gradeBook1 created for course: " << gradeBook1.getCourseName() << "\nThis course is presented by: " << gradeBook1.getInstructorName()
<< "\n\ngradeBook2 created for course: " << gradeBook2.getCourseName() << "\nThis course is presented by: " << gradeBook2.getInstructorName()
<< endl;
string omega;
cin >> omega;
} // end main
/**************************************************************************
* (C) Copyright 1992-2012 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. These efforts include the *
* development, research, and testing of the theories and programs *
* to determine their effectiveness. The authors and publisher make *
* no warranty of any kind, expressed or implied, with regard to these *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or *
* consequential damages in connection with, or arising out of, the *
* furnishing, performance, or use of these programs. *
**************************************************************************/
GradeBook.h
Codice:// Fig. 3.11: GradeBook.h
// GradeBook class definition. This file presents GradeBook's public
// interface without revealing the implementations of GradeBook's member
// functions, which are defined in GradeBook.cpp.
#include <string> // class GradeBook uses C++ standard string class
using namespace std;
// GradeBook class definition
class GradeBook
{
public:
GradeBook( string, string ); // constructor that initializes courseName
void setCourseName( string ); // function that sets the course name
void setInstructorName(string); // function that sets the instructor's name
string getCourseName(); // function that gets the course name
string getInstructorName(); // function that gets the instructor's name
void displayMessage(); // function that displays a welcome message
private:
string courseName; // course name for this GradeBook
string instructorName; // name of the course Instructor
}; // end class GradeBook
/**************************************************************************
* (C) Copyright 1992-2012 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. These efforts include the *
* development, research, and testing of the theories and programs *
* to determine their effectiveness. The authors and publisher make *
* no warranty of any kind, expressed or implied, with regard to these *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or *
* consequential damages in connection with, or arising out of, the *
* furnishing, performance, or use of these programs. *
**************************************************************************/
GradeBook.cpp
Codice:// Fig. 3.12: GradeBook.cpp// GradeBook member-function definitions. This file contains
// implementations of the member functions prototyped in GradeBook.h.
#include <iostream>
#include "GradeBook.h" // include definition of class GradeBook
using namespace std;
// constructor initializes courseName with string supplied as argument
GradeBook::GradeBook( string name, string instructor )
{
setCourseName( name ); // call set function to initialize courseName
setInstructorName( instructor); // call set function to initialize instructorName
} // end GradeBook constructor
// function to set the course name
void GradeBook::setCourseName( string name )
{
courseName = name; // store the course name in the object
} // end function setCourseName
void GradeBook::setInstructorName(string instructor)
{
instructorName = instructor;
}
// function to get the course name
string GradeBook::getCourseName()
{
return courseName; // return object's courseName
} // end function getCourseName
string GradeBook::getInstructorName()
{
return instructorName;
}
// display a welcome message to the GradeBook user
void GradeBook::displayMessage()
{
// call getCourseName to get the courseName
cout << "Welcome to the grade book for\n" << getCourseName()
<< "!" << endl;
} // end function displayMessage
/**************************************************************************
* (C) Copyright 1992-2012 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. These efforts include the *
* development, research, and testing of the theories and programs *
* to determine their effectiveness. The authors and publisher make *
* no warranty of any kind, expressed or implied, with regard to these *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or *
* consequential damages in connection with, or arising out of, the *
* furnishing, performance, or use of these programs. *
**************************************************************************/
Spero ti possa essere d'aiuto ;)
Grazie mille (y)
Ultimamente sono mancato spesso a scuola, e mentre non c'ero la prof. ha spiegato le funzioni friend. Ora, per quanto ho capito servono per fare un'operazione tra elementi della stessa classe... ma sono tanto fondamentali? In un programma lasciato di recente c'era questa classe (sto omettendo alcune parti)
class fattura {
private:
int importo;
struct data{
int gg;
int mm;
} dataemissione, datapagamento;
public:
void inserimento ();
void visualizzazione ();
};
Ora, per fare un'operazione tra dataemissione.gg e datapagamento.gg (esempio) dovrei utilizzare una funzione friend per forza? Alla fine sono due variabili distinte
Mentre facevo il programma non ho fatto caso al problema ed ho svolto il programma come nulla fosse, ma sentendo la prof. spiegare oggi mi è venuto questo dubbio...
No. Una funzione friend è una funzione definita fuori dalla classe MA che la classe dichiara amica e quindi può accedere agli attributi e ai metodi privati della classe.
Ho risposto alla tua domanda? Perché, imho, sei partito da una premessa sbagliata e quello che è venuto dopo ha poco senso.Codice:class A {
int a;
public:
A () { a = 0 };
friend void foo();
};
void foo(A a_obj) {
a_obj.a = 10; // Non sarebbe permesso in una funzione non-friend
}
Btw, mai usate funzioni friend e neanche classi friend. Penso vadano contro ai principi base dell'OOP anche se in alcuni particolari casi sono strettamente necessarie.
Aggiungo che le amicizie non si ereditano :)
Inviato dal mio Nexus 4