Quindi vedi se ho capito e vedi se così va bene.
typedef char* buffer [DIM] che ho dichiarato il veicololib.h , dichiaro buffer come variabile automatica locale all'interno della funzione Copia nel modulo Supportofun.cpp e così viene allocata nell'area stack della memoria. E quindi devo dichiaralo solo così giusto?char *buffer [DIM]; . void Copia(char *&) ? E quindi nel main gli passo solo s1?
Beh, è una altra soluzione.
char *nome [dim] è un array di puntatori; a te serve un array normalissimo che è char nome[dim].
char *Copia(char *buffer)
{
cin.getline(buffer, DIM-1, '\n');
// delete [] s; ... lo togliamo
char *s=new char [strlen(buffer)+1];
strcpy(s, buffer);
// buffer[]=nullptr; ASSOLUTAMENTE NO!
cin.ignore();
return s;
}
// nel Main, o dove chiami Copia
Str s1 = Copia(buffer); // dove buffer e' char buffer[DIM];
// ora fai le tue cose con s1
...
// quando non ti serve piu', prima che esca dalla "visibilita' " locale chiami:
delete [] s1;
#ifndef VEICOLOLIB_H
#define VEICOLOLIB_H
#include <iomanip>
#include <cstring>
#include <iostream>
#include <cstdlib>
#define DIM 100
using namespace std;
namespace Parcheggio{
typedef char buffer [DIM];
class Veicolo{
friend ostream &operator<<(ostream &, const Veicolo &);
friend istream &operator>>(istream &, Veicolo &);
private:
char *Nometipo;
char *Marca;
protected:
virtual ostream &stampa(ostream &)const;
virtual istream &leggi(istream &);
public:
Veicolo(const char * ="", const char * ="");
Veicolo(const Veicolo &);
~Veicolo();
void set_Veicolo(const Veicolo &);
void set_Nometipo(const char *);
void set_Marca(const char *);
const char * get_Nometipo() { return Nometipo; };
const char * get_Marca() { return Marca; };
const Veicolo &operator=(const Veicolo &);
bool operator==(const Veicolo &)const;
bool operator!=(const Veicolo &)const;
};
}
#endif#include "Veicololib.h"
namespace Parcheggio{
Veicolo::Veicolo(const char *N, const char *M): Nometipo(new char [strlen(N)+1]), Marca(new char [strlen(M)+1]){
strcpy(Nometipo, N);
strcpy(Marca, M);
}
Veicolo::Veicolo(const Veicolo &V) : Nometipo(new char [strlen(V.Nometipo)+1]), Marca(new char [strlen(V.Marca)+1]){
strcpy(Nometipo, V.Nometipo);
strcpy(Marca, V.Marca);
}
void Veicolo::set_Veicolo(const Veicolo &V){
set_Nometipo(V.Nometipo);
set_Marca(V.Marca);
}
void Veicolo::set_Nometipo(const char *N){
delete[] Nometipo;
Nometipo= new char [strlen(N)+1];
strcpy(Nometipo, N);
}
void Veicolo::set_Marca(const char *M){
delete[] Marca;
Marca= new char [strlen(M)+1];
strcpy(Marca, M);
}
Veicolo::~Veicolo(){
delete Nometipo;
delete Marca;
}
const Veicolo &Veicolo::operator=(const Veicolo & V){
if(&V != this){
if(Nometipo) delete [] Nometipo;
if(Marca) delete [] Marca;
set_Veicolo(V);
}
return *this;
}
bool Veicolo::operator==(const Veicolo &V)const {
return (!strcmp(Nometipo, V.Nometipo) && !strcmp(Marca, V.Marca));
}
bool Veicolo::operator!=(const Veicolo &V)const{
return (!this->operator==(V));
}
ostream &operator<<(ostream &out, const Veicolo &V){
return V.stampa(out);
}
istream &operator>>(istream &in, Veicolo &V){
return V.leggi(in);
}
ostream &Veicolo::stampa(ostream &out)const{
out<<"| Nome del tipo di veicolo: "<<Nometipo<<"| Marca: "<<Marca;
return out;
}
istream &Veicolo::leggi(istream &in){
buffer b;
cout<<"Inserisci il nome del tipo di veicolo: ";
in.getline(b, DIM-1, '\n');
set_Nometipo(b);
in.ignore();
cout<<"Inserisci la marca del veicolo: ";
in.getline(b, DIM-1,'\n');
set_Marca(b);
in.ignore();
return in;
}
}#ifndef AUTOMOBILELIB_H
#define AUTOMOBILELIB_H
#include "Veicololib.h"
namespace Parcheggio{
class Automobile: public Veicolo{
friend ostream &operator<<(ostream &,const Automobile &);
friend istream &operator>>(istream &, Automobile &);
private:
char *Alimentazione;
protected:
virtual ostream &stampa(ostream &)const;
virtual istream &leggi(istream &);
public:
Automobile(const char * ="", const char * ="", const char * ="");
Automobile(const Automobile &);
~Automobile(){ delete [] Alimentazione;};
void set_Alimentazione(const char*);
const char * get_Alimentazione(){ return Alimentazione; };
const Automobile &operator=(const Automobile &);
bool operator==(const Automobile &)const;
bool operator!=(const Automobile &)const;
};
}
#endif#include "Automobilelib.h"
namespace Parcheggio{
Automobile::Automobile(const char *N, const char * M, const char *A) : Veicolo(N, M), Alimentazione(new char [strlen(A)+1]){
strcpy(Alimentazione, A);
}
Automobile::Automobile(const Automobile & A) : Veicolo(A), Alimentazione(new char [strlen (A.Alimentazione)+1]){
strcpy(Alimentazione, A.Alimentazione);
}
void Automobile::set_Alimentazione(const char *A){
delete [] Alimentazione;
Alimentazione= new char [strlen(A)+1];
strcpy(Alimentazione, A);
}
const Automobile &Automobile::operator=(const Automobile &A){
if(&A!=this){
Veicolo::operator=(A);
if(Alimentazione) delete [] Alimentazione;
set_Alimentazione(A.Alimentazione);
}
}
bool Automobile::operator==(const Automobile &A)const{
return (Veicolo::operator==(A) && !strcmp(Alimentazione, A.Alimentazione));
}
bool Automobile::operator!=(const Automobile &A)const{
return ( !this->operator==(A));
}
ostream &operator<<(ostream &out, const Automobile &A){
return A.stampa(out);
}
istream &operator>>(istream &in, Automobile &A){
return A.leggi(in);
}
ostream &Automobile::stampa(ostream &out)const{
Veicolo::stampa(out);
out<<"| Alimentazione: "<<Alimentazione<<endl;
return out;
}
istream &Automobile::leggi(istream &in){
buffer b;
Veicolo::leggi(in);
in.getline(b, DIM-1, '\n');
set_Alimentazione(b);
in.ignore();
return in;
}
}#ifndef MOTOLIB_H
#define MOTOLIB_H
#include "Veicololib.h"
namespace Parcheggio{
class Moto: public Veicolo{
friend ostream &operator<<(ostream &,const Moto &);
friend istream &operator>>(istream &, Moto &);
private:
char *Tipo;
protected:
virtual ostream &stampa(ostream &)const;
virtual istream &leggi(istream &);
public:
Moto(const char * ="", const char * ="", const char * ="");
Moto(const Moto &);
~Moto(){ delete [] Tipo; };
void set_Tipo(const char *);
const char * get_Tipo() { return Tipo; };
const Moto &operator=(const Moto &);
bool operator==(const Moto &);
bool operator!=(const Moto &);
};
}
#endif#include "Motolib.h"
namespace Parcheggio{
Moto::Moto(const char *N, const char *M, const char *T) : Veicolo(N,M), Tipo(new char [strlen(T)+1]){
strcpy(Tipo,T);
}
Moto::Moto(const Moto &M) : Veicolo(M), Tipo(new char [strlen(M.Tipo)+1]){
strcpy(Tipo,M.Tipo);
}
void Moto::set_Tipo(const char *T){
delete [] Tipo;
Tipo=new char [strlen(T)+1];
strcpy(Tipo,T);
}
const Moto &Moto::operator=(const Moto &M){
if(&M!=this){
Veicolo::operator=(M);
if(Tipo) delete [] Tipo;
set_Tipo(M.Tipo);
}
}
bool Moto::operator==(const Moto &M){
return (Veicolo::operator==(M) && strcmp(Tipo, M.Tipo));
}
bool Moto::operator!=(const Moto &M){
return (! this->operator==(M));
}
ostream &operator<<(ostream &out, const Moto &M){
return M.stampa(out);
}
istream &operator>>(istream &in, Moto &M){
return M.leggi(in);
}
ostream &Moto::stampa(ostream &out)const {
Veicolo::stampa(out);
out<<"| Tipo: "<<Tipo;
return out;
}
istream &Moto::leggi(istream &in){
buffer b;
Veicolo::leggi(in);
in.getline(b, DIM-1, '\n');
set_Tipo(b);
in.ignore();
return in;
}
}#ifndef GARAGELIB_H
#define GARAGELIB_H
#include "Veicololib.h"
#include "Automobilelib.h"
#include "Motolib.h"
#include "Errorelib.h"
#include <fstream>
namespace Parcheggio{
typedef Veicolo *pntVeicolo;
class Garage{
private:
static const int N=20;
pntVeicolo Vett[N];
static int Count;
public:
Garage(){for(int i=0; i<N; i++) Vett[i]=0; };
bool Empty() const {return Count==0;};
bool Full() const {return Count==N;};
int Immetti(Veicolo *)throw(Errore);
pntVeicolo Estrai(const int &);
void Stampa_Video()const;
void Stampa_File(const char *)const throw(const char *);
};
}
#endif#include "Garagelib.h"
namespace Parcheggio{
int Garage::Count=0;
int Garage::Immetti(Veicolo *V) throw(Errore){
int i;
if(strcmp(V->get_Nometipo(), "Automobile") && strcmp(V->get_Nometipo(), "Motocicletta")){
throw(Errore(V->get_Nometipo()));
}
Vett[Count]=V;
Count++;
return Count-1;
}
pntVeicolo Garage::Estrai(const int &P){
if(Count>=P){
pntVeicolo temp= Vett[P];
for(int i=P; i<Count; i++){
Vett[i]=Vett[i+1];
}
Count--;
return temp;
}
}
void Garage::Stampa_Video()const{
for(int i=0; i<Count; i++ ){
cout<<i<<") "<<*Vett[i]<<endl;
}
}
void Garage::Stampa_File(const char *Nome)const throw(const char *){
fstream File;
File.open(Nome);
if(!File){
throw("\n Errore durante l'apertura del file \n");
}
for(int i=0; i<N; i++){
if(Vett[i]){
File<<*Vett[i]<<endl;
}
}
File.close();
}
}#ifndef ERRORELIB_H
#define ERRORELIB_H
#include <string>
using namespace std;
namespace Parcheggio{
class Errore{
private :
string error;
public:
Errore(string E): error(E){};
const char *what() const;
};
}
#endif#include "Errorelib.h"
namespace Parcheggio{
const char *Errore::what() const {
string msg;
msg = "\n Errore! Il veicolo inserito non è valido: " + error;
return msg.c_str();
}
}#ifndef SUPPORTOLIB_H
#define SUPPORTOLIB_H
#include "Veicololib.h"
namespace Parcheggio{
typedef char *Str;
void Stampa_Menu();
char *Copia(char *);
}
#endif#include "Supportolib.h"
namespace Parcheggio{
void Stampa_Menu(){
cout<<"/***Benvenuti all'interno del garage**/\n\n";
cout<<"[0] Uscita \n";
cout<<"[1] Insersci un veicolo nel garage \n";
cout<<"[2] Estrai un veicolo dal garage \n";
cout<<"[3] Stampa a video la lista dei veicoli \n";
cout<<"[4] Stampa su file la lista dei veicoli \n";
cout<<"Premi il tasto per scegliere l'operazione da svolgere : ";
}
char *Copia(char *buffer){
cin.getline(buffer, DIM-1, '\n');
s=new char [strlen(buffer)+1];
strcpy(s, buffer);
cin.ignore();
}
}#include <iostream>
#include <cstdlib>
#include <fstream>
#include "Veicololib.h"
#include "Automobilelib.h"
#include "Motolib.h"
#include "Garagelib.h"
#include "Errorelib.h"
#include "Supportolib.h"
using namespace std;
using namespace Parcheggio;
int main(int argc, char** argv) {
int opzione;
Garage G;
buffer b;
do{
system("cls");
Stampa_Menu();
cin>>opzione;
switch(opzione){
case(1):
cout<<"\n Inserisci un Automobile o una Motocicletta [A/M] : ";
char risp;
cin>>risp;
if(!G.Full()){
if(risp=='A'){
cin.ignore();
cout<<"\n Inserisci la marca dell'Automobile: ";
Str s1=Copia(b);
cout<<"\n Inserisci l'alimentazione dell'Automobile: ";
Str s2=Copia(b);
try{
G.Immetti(new Automobile("Automobile", s1, s2));\\ scusate l'ignoranza ma s1 e s2 si sono trasformati in dati dell'oggetto?
delete [] s1; \\quindi non potrei de allocarli cosi?
delete [] s2;
}
catch(Errore e){
cout<<e.what()<<endl;
}
}else if(risp=='M'){
cin.ignore();
cout<<"\n Inserisci la marca della Motocicletta: ";
Str s3=Copia(b);
cout<<"\n Inserisci il tipo di Motocilcetta: ";
Str s4=Copia(b);
try{
G.Immetti(new Moto("Motocicletta", s3, s4)); \\ scusate l'ignoranza ma s1 e s2 si sono trasformati in dati dell'oggetto?
delete [] s3; \\quindi non potrei de allocarli cosi?
delete [] s4;
}
catch(Errore e){
cout<<e.what()<<endl;
}
}
}else{
cout<<"\n Il Garage è pieno \n";
}
break;
case(2):
cin.ignore();
cout<<"\n Inserisci la posizione del veicolo da estrarre: ";
if(!G.Empty()){
int pos;
cin>>pos;
cin.ignore();
cout<<"\n Il veicolo estratto è :";
cout<<endl<<G.Estrai(pos)<<endl;
cout<<"\n il garage adesso è composto dai seguenti veicoli: ";
G.Stampa_Video();
}else{
cout<<"\n Il garage è vuoto \n ";
}
break;
case(3):
cout<<"\n Lista dei veicoli presenti nel garage: ";
if(!G.Empty()){
G.Stampa_Video();
}else cout<<"\n Il garage è vuoto \n ";
break;
case(4):
cin.ignore();
cout<<"\n Inserisci il Percorso del file: ";
cin.getline(b, DIM-1, '\n');
try{
G.Stampa_File(b);
}catch(const char *b){
cout<<b<<endl;
}
break;
}
system("pause");
}while(opzione!=0);
return 0;
}int main(int argc, char** argv) {
int opzione;
Garage G;
buffer b;
do{
system("cls");
Stampa_Menu();
cin>>opzione;
switch(opzione){
case(1):
cout<<"\n Inserisci un Automobile o una Motocicletta [A/M] : ";
char risp;
cin>>risp;
if(!G.Full()){
if(risp=='A'){
cin.ignore();
Automobile Atemp;
cout<<"\n Inserisci la marca dell'Automobile: ";
cin.getline(b, DIM-1, '\n');
Atemp.set_Marca(b);
cin.ignore();
cout<<"\n Inserisci l'alimentazione dell'Automobile: ";
cin.getline(b, DIM-1, '\n');
Atemp.set_Alimentazione(b);
cin.ignore();
try{
G.Immetti(new Automobile("Automobile", Atemp.get_Marca(), Atemp.get_Alimentazione()));
Atemp.~Automobile();
}
catch(Errore e){
cout<<e.what()<<endl;
}
}else if(risp=='M'){
cin.ignore();
Moto Mtemp;
cout<<"\n Inserisci la marca della Motocicletta: ";
cin.getline(b, DIM-1, '\n');
Mtemp.set_Marca(b);
cin.ignore();
cout<<"\n Inserisci il tipo di Motocilcetta: ";
cin.getline(b, DIM-1, '\n');
Mtemp.set_Tipo(b);
cin.ignore();
try{
G.Immetti(new Moto("Motocicletta", Mtemp.get_Marca(), Mtemp.get_Marca()));
Mtemp.~Moto();
}
catch(Errore e){
cout<<e.what()<<endl;
}
}
}else{
cout<<"\n Il Garage è pieno \n";
}
break;
Lascia stare la seconda soluzione, non ha senso e addirittura chiami il distruttore manualmente.
G.Immetti(new Automobile("Automobile", s1, s2));\\ scusate l'ignoranza ma s1 e s2 si sono trasformati in dati dell'oggetto?
delete [] s1; \\quindi non potrei de allocarli cosi?
delete [] s2; f(risp=='A'){
cin.ignore();
Automobile Atemp;
cout<<"\n Inserisci la marca dell'Automobile: ";
cin.getline(b, DIM-1, '\n');
Atemp.set_Marca(b);
cin.ignore();
cout<<"\n Inserisci l'alimentazione dell'Automobile: ";
cin.getline(b, DIM-1, '\n');
Atemp.set_Alimentazione(b);
cin.ignore();
try{
G.Immetti(new Automobile("Automobile", Atemp.get_Marca(), Atemp.get_Alimentazione()));
// se usi questa strada... conviene magari e' piu' elegante :
// Atemp.set_Nometipo("Automobile"); -> fatta in precedenza, non serve in "try"
// G.Immetti(new Automobile( Atemp));
// questo invece:
// Atemp.~Automobile(); NO!!! e' inutile
}
catch(Errore e){
cout<<e.what()<<endl;
}
} // Atemp si dealloca da sola qui -> fine visibilita' f(risp=='A'){
buffer b1, b2;
cin.ignore();
cout<<"\n Inserisci la marca dell'Automobile: ";
cin.getline(b1, DIM-1, '\n');
cin.ignore();
cout<<"\n Inserisci l'alimentazione dell'Automobile: ";
cin.getline(b2, DIM-1, '\n');
cin.ignore();
try{
G.Immetti(new Automobile("Automobile", b1, b2));
}
catch(Errore e){
cout<<e.what()<<endl;
}
}Bruttpitt grazie mille sei stato di grande aiuto ho usato la prima soluzione con Atemp ecc... Vi chiedo un ultima cosa se vi va, vorrei complicarmi la vita vedo che la gestione dell'errore in pratica è finta non si attiva mai. Ho pensando ad una soluzione ed ho unito e modificato la seconda soluzione con la prima, è un pò bruttina sinceramente perchè fa due volte la domanda su che tipo di veicolo si è inserito ma non ho pensato a nulla di meglio.
#include <iostream>
#include <cstdlib>
#include <fstream>
#include "Veicololib.h"
#include "Automobilelib.h"
#include "Motolib.h"
#include "Garagelib.h"
#include "Errorelib.h"
#include "Supportolib.h"
using namespace std;
using namespace Parcheggio;
int main(int argc, char** argv) {
int opzione;
Garage G;
buffer b;
char risp1[]="Automobile";
char risp2[]="Motocicletta";
char risp3;
do{
system("cls");
Stampa_Menu();
cin>>opzione;
switch(opzione){
case(1):
cout<<"\n Inserisci il tipo di Veicolo : ";
cin.getline(b, DIM-1, '\n');
if(!G.Full()){
Veicolo Vtemp;
Vtemp.set_Nometipo(b);
cin.ignore();
cout<<"\n Inserisci la marca del Veicolo: ";
cin.getline(b, DIM-1, '\n');
Vtemp.set_Marca(b);
cin.ignore();
cout<<"Hai inserito un Automobile o una Moto?[A/M]: ";
cin>>risp3;
if(risp3=='A'){
Automobile Atemp;
buffer b2;
cout<<"\n Inserisci l'alimentazione dell'Automobile: ";
cin.getline(b2, DIM-1, '\n');
Atemp( Vtemp.get_Nometipo(), Vtemp.get_Marca(), b2);
cin.ignore();
try{
G.Immetti(new Automobile(Atemp));
}
catch(Errore e){
cout<<e.what()<<endl;
}
}else if(risp3=='M'){
Moto Mtemp;
buffer b3;
cout<<"\n Inserisci il tipo di Motocilcetta: ";
cin.getline(b3, DIM-1, '\n');
Mtemp( Vtemp.get_Nometipo(), Vtemp.get_Marca(), b3);
cin.ignore();
try{
G.Immetti(new Moto(Mtemp));
}
catch(Errore e){
cout<<e.what()<<endl;
}
}
}else{
cout<<"\n Il Garage è pieno \n";
}
break;
Comunque faccio veramente fatica a leggere il codice, è identato malissimo.
Parcheggio::Automobile(const char *, const char *, Parcheggio::buffer), quindi il problema sta tra gli argomenti della chiamata, ed esso è buffer. Se invece di passargli buffer passi &buffer[0] il problema dovrebbe risolversi.
try{
G.Immetti(new Automobile(Vtemp.get_Nometipo(), Vtemp.get_Marca(), /* col cast */ b2));
}
catch(Errore e){
cout<<e.what()<<endl;
} Automobile *auto = new Automobile;
// poi acquisici gli input e usi set_Nometipo(), set_Marca()... etc per definire i membri di "auto"
// ed infine la "immetti" nel "garage"