Problema para terminar y compilar un proyecto

[pyromiyuve]

Iniciado por pyromiyuve

Hola! He logrado ir avanzando con mi codigo, pero todavia tengo problemas, ya que no se como terminarlo...

Se que lo mas probable es que no me logre explicar bien asi que anexo el enunciado de mi proyecto para las dudas en el link:

Código HTML:

http://ccg.ciens.ucv.ve/~esmitt/ayed/II-2011/proyecto2.pdf
 

y mi codigo del proyecto es:

Código c++:

#include<stdio.h>
#include<stdio.h>
#include<iostream>
using namespace std;
 
int Capital=20; 
 
int cantidadItems(char* c){ //Funcion que calcula cuantos repuestos disponemos
    int i=0;int k=0;
    do{
        if(*(c+i)==' '){
            k++;
        }
        i++;
    }while(*(c+i)!=('\0'));
    
    return(k+1);
};
 
int cant(char* c, int k){
    do{
        k++;
    }while((*(c+k)!=('\0')) && (*(c+k)!=(' ')));
    
    return(k);
};
 
//no se puede utilizar "set"
 
class Vehiculo{
    string placa;
    char puerta;
    int averiado;
    public:
        Vehiculo(string placa, char puerta, int averiado){
            this->placa = placa;//this es un puntero que se referencia a si mismo, es decir a mi clase! 
            this->puerta = puerta;
            this->averiado = averiado;
        }
        string get_placa(){
            return placa;
        }
        char get_puerta(){
            return puerta;
        }       
        int get_averiado(){
            return averiado;
        }
};
class Cola{
    class Nodo{
        Vehiculo *v;
        Nodo *siguiente;
        public:
            Nodo(Vehiculo *v){
                this->v = v;
                siguiente = NULL;
            }
            Vehiculo* get_v(){
                return v;
            }
            void set_siguiente(Nodo *n){
                siguiente = n;
            }   
            Nodo* get_siguiente(){
                return siguiente;
            }
    };
    
    Nodo *pri, *ult;
    public:
        Cola(){
            pri = ult = NULL;
        }
        Vehiculo* primero(){
            return pri->get_v();
        }
        void encolar(Vehiculo* v){
            Nodo *nuevo = new Nodo(v);
            if(ult==NULL){
                pri = ult = nuevo;
            }else{
                ult->set_siguiente(nuevo);
                ult = nuevo;
            }
        }
        
        void desencolar(){
            Nodo *aux = pri;
            pri = pri->get_siguiente();
            delete aux;
            if(pri==NULL)
                ult = NULL;
        }
        
        bool esVacia(){
            return pri==NULL;
        }
};
 
 
int i = 0;
void mostrar(char puerta, Cola *c){
    while(!c->esVacia()){
        if(puerta=='A'){
            cout << "Vehiculo " << ++i << ": " << c->primero()->get_placa() << endl;
        }else if(puerta=='B'){
            cout << "Vehiculo " << ++i << ": " << c->primero()->get_placa() << endl;
        }c->desencolar();
    }
}
void verificar(Lista *l, Cola *a, Cola *b){
    if(!l->esVacia()){
        Lista *aux = new Lista(); aux->p = l->primero();
        while(aux->p!=NULL){
            if(aux->acceder(aux->p)=='A'){
                mostrar(aux->acceder(aux->p),a);
            }else if(aux->acceder(aux->p)=='B'){
                mostrar(aux->acceder(aux->p),b);
            }aux->p = aux->siguiente(aux->p);
        }delete aux;
    }
 
};
 
//LISTA DE ORDEN
class Lista{
    class Nodo{
        char orden;
        Nodo *siguiente;
        public:
            Nodo(char orden){
                this->orden = orden;
                siguiente = NULL;
            }
            
            char get_orden(){
                return orden;
            }
            
            void set_siguiente(Nodo *n){
                siguiente = n;
            }
            
            Nodo* get_siguiente(){
                return siguiente;
            }
    };
    
    Nodo *head;
    int cantidad;
    typedef Nodo* Posicion;
    public:
        Posicion p;
        
        Lista(){
            head = NULL;
            cantidad = 0;
        }
        
        void insertar(Posicion p, char orden){
            Nodo *nuevo = new Nodo(orden);
            if(nuevo!=NULL){//COMPRUEBO QUE HAYA MEMORIA
                if(head==NULL){
                    head = nuevo;
                    cantidad++;
                }else{
                    Nodo* r = head;
                    while(r->get_siguiente()!=p){
                        r = r->get_siguiente();
                    }
                    
                    if(p==NULL){
                        r->set_siguiente(nuevo);
                    }else{
                        nuevo->set_siguiente(r->get_siguiente());
                        r->set_siguiente(nuevo);
                    }
                }
            }
        }
        
        Posicion fin(){
            Nodo *r = head;
            while(r->get_siguiente()!=NULL){
                r = r->get_siguiente();
            }return r;
        }
        
        Posicion primero(){
            if(head!=NULL){
                return head;
            }else{
                return fin();
            }
        }
        
        Posicion siguiente(Posicion p){
            return p->get_siguiente();
        }
        
        char acceder(Posicion p){
            return p->get_orden();
        }
        
        bool esVacia(){
            return head==NULL;
        }
};
 
class myString{
    public:
        Lista *primero;
        Lista *ultimo;
        Lista *aux;
        int contador;
        
    public:
        myString(){;
            primero = NULL;
            ultimo = NULL;
            aux = NULL;
            contador = 0;
}
 
    void Insertar (char c);
    void Mostrar ();
    
};
 
 void myString::Insertar(char aux){
 
    Lista* nuevo= new nodoLista();
    nuevo->caracter=aux; 
    if(primero==NULL && ultimo==NULL){
        primero=nuevo;
        ultimo=nuevo;
    }else{
        ultimo->siguiente=nuevo;
        ultimo=nuevo;
        contador++; //revisar no estoy segura de si hace falta
    }
};
 
void myString::Mostrar(){
    aux=primero;
    do{
    cout<<aux->caracter;
    aux=aux->siguiente;
    }while(aux!=NULL);
    
};
 
class Repuestos{ //Pila donde voy a guardar los Repuestos
    public:
        nodoCola *ultimo;
        nodoCola *aux;
        nodoCola *tope;
        int contador;//cantidad de carros que entran
        public:
        Repuestos(){
            tope=NULL;
            contador=0;
            ultimo=NULL;
            aux=NULL;
        }
        void Insertar(char placa[], char puerta, char averiado, char* item, int contador); 
        void Mostrar();
    void Usados(int i);
};
 
void Repuestos :: Usados(char placa[], char puerta, char averiado ,char* item,int contador){// FALTA por resolver!!!!!!!!!!!!
 
    int Ing=Capital;
    int egreso=0;
    int ingreso=0;
    int c;
    
    
    if(ultimo->Averiado=='0'){ // se repara y factura a la vez
        
            egreso=((ultimo->contador)*1); //Contador indica la cantidad de repuestos a reparar en el carro que esta siendo atendido
            ingreso=((ultimo->contador)*0);
            Capital +=(ingreso-egreso); //Indica la ganancia obtenida por Liam tras la reparacion del carro atendido
            
        };
         
    aux=ultimo;
    ultimo=aux->siguiente;//eliminacion del carro: se libera el nodo
    cout<<"Vehiculo "<<i<<": ";
    
    for(k=0;k<9;k++)
    {
        cout<<aux->Placa[k];
    }
    cout<<"\n"<<-1*(egreso)<<"\n"<<ingreso<<endl;
    
    //apilamos FALTA POR REVISAR Y TERMINAR DE HACER!!!!
 
    nodoCola *aux
    aux->siguiente=ultimo;
    ultimo=aux;
};
 
void Repuestos::Insertar(char placa[], char puerta, char averiado ,char* item,int contador){
  nodoCola* nuevo=new nodoCola();
   int k=0;
   
   for(k=0;k<9;k++){
        nuevo->placa[k]=placa[k];
    };
    
   nuevo->puerta = puerta;
   nuevo->averiado = averiado;
   nuevo->Item = item;  
   nuevo->contador = contador;
    //se empiezan ha armar los Repuestos
    if(ultimo==NULL){
        ultimo=nuevo;
    }else{
        nuevo->siguiente=ultimo;
        ultimo=nuevo;
    };  
    
    contador++; //cantidad de carros
};
 
void Repuestos::Mostrar(){ //Muestra la placa del ultimo carro en insertar repuestos 
    int k=0;
    for(k=0;k<9;k++){
        cout<<aux->placa[k];
    }   
};
    
void Repuestos::Reparar(int i){
 
    int Ing=Capital;
    int egreso=0;
    int ingreso=0;
    int k;
    
    
    if(ultimo->averiado=='1'){ // se repara y factura a la vez
        
            egreso=((ultimo->contador)*2); 
            ingreso=((ultimo->contador)*3);
            Capital +=(ingreso-egreso); 
            
        
    }else if((Ing-ultimo->contador)>0){ //si averiado es igual a cero verificamos si tenemos capital para comprar
            Capital-=ultimo->contador; //en caso de que el capital sea positivo, se pueda comprar.Se realiza una sustraccion al ingreso ingreso neto de Liam
            egreso=ultimo->contador;
        };
         
    aux=ultimo;
    ultimo=aux->siguiente;//eliminacion logica
    cout<<"Vehiculo "<<i<<": ";
    
    for(k=0;k<9;k++)
    {
        cout<<aux->placa[k];
    }
    cout<<"\n"<<-1*(egreso)<<"\n"<<ingreso<<endl;
     
     //desapilamos
 
    delete(aux);//eliminacion del carro atendido
};
 
// MENU PRINCIPAL DEL PROGRAMA
int main(){
    int n,i,k;
    char *c=NULL;//entrada
    Vehiculo *v;
    string placa = "";
    char averiado, puerta, orden;
    char aux;
    char *items=NULL;
    Repuestos A;
    Repuestos B;
    myString string;
    
    Cola *puertaA = new Cola(), *puertaB = new Cola();
    Lista *lorden = new Lista();
 
    cin>>n; //cantidad de vehiculos a ingresar
    cin.ignore(); 
    for(i=0;i<n;i++)
    {
        fflush(stdin); 
        c=new char[15];
        cin.getline(c,15); 
        k=0;
        do{
            placa[k]=*c;     //calcula la cantidad de atributos necesarios para la placa
            k++; c++;        //placa
        }while(*c!=' ');
        
        while(k<10){
            placa[k]=' '; //si la placa posee menos de 10 elementos alfanumericos,se completan los espacios con "vacio"
            k++;
        }    
            
        puerta=(*(c+1)); //calcula el atributo: puerta
        averiado=(*(c+3));  //calcula el atributo: averiado     
    
        
        fflush(stdin); 
        items=new char[1002];
        cin.getline(items,1002);
        k=cantidadItems(items);
    
        cin >> placa >> puerta >> averiado;
        v = new Vehiculo(placa,puerta,averiado);
            
        if(puerta=='A' || puerta=='a') //Insertamos teniendo en cuenta la puerta
        {
            puertaA->encolar(v);
            A.Insertar(placa,puerta,averiado,items,k); 
            
        }
        else if(puerta=='B' || puerta=='b')
        {
            puertaB->encolar(v);
            B.Insertar(placa,puerta,averiado,items,k);
            
        }
    }   
 
 
        for(int j = 0; j < n; ++j){
        cin >> orden;
        lorden->insertar(NULL,orden);
    }
    
        verificar(lorden,puertaA,puertaB);
        delete puertaA, puertaB, v, lorden;
 
 
    for(i=0;i<n;i++){
        cin>>aux;
        string.Insertar(aux);
    }
    string.aux=string.primero;
    for(i=0;i<n;i++){
        if(string.aux->caracter=='A' || string.aux->caracter=='a'){
            if(A.ultimo!=NULL){
                A.Reparar(i+1);
                
            }else{
                B.Reparar(i+1); 
                
            }   
        }else if(puerta=='B' || puerta=='b'){
            if(B.ultimo!=NULL){
                B.Reparar(i+1);
                
            }else{
                A.Reparar(i+1);
            
                }   
        }
        string.aux=string.aux->siguiente;
    }
    cout<<Capital<<endl;
return 0;
};
 
}
 

Podria alguien por favor ayudarme?

Muchas gracias

[pyromiyuve]

Bueno he logrado ir avanzando en mi proyecto pero ahora tengo una serie de errores con pase de argumentos y funciones al compilar, podria alguien ayudarme con el nuevo codigo, por favor?

Código C++:

#include<stdio.h>
#include<iostream>
using namespace std;
 
//Variables Globales
 
int Capital=20; 
 
int cantidadItems(char* c){ //Funcion que devuelve un Entero y se encarga de calcula cuantos repuestos disponemos
    int i=0;int k=0;
    do{
        if(*(c+i)==' '){
            k++;
        }
        i++;
    }while(*(c+i)!=('\0'));
    
    return(k+1);
};
 
int cant(char* c, int k){
    do{
        k++;
    }while((*(c+k)!=('\0')) && (*(c+k)!=(' ')));
    
    return(k);
};
 
//LISTA DE ORDEN
class Lista{
    class Nodo{
        char orden;
        Nodo *siguiente;
        public:
            Nodo(char orden){
                this->orden = orden;
                siguiente = NULL;
            }
            
            char get_orden(){
                return orden;
            }
            
            void set_siguiente(Nodo *n){
                siguiente = n;
            }
            
            Nodo* get_siguiente(){
                return siguiente;
            }
    };
    
    Nodo *head;
    int cantidad;
    typedef Nodo* Posicion;
    public:
        Posicion p;
        char caracter;
        Lista(){
            head = NULL;
            cantidad = 0;
        }
        
        void insertar(Posicion p, char orden){
            Nodo *nuevo = new Nodo(orden);
            if(nuevo!=NULL){//COMPRUEBO QUE HAYA MEMORIA
                if(head==NULL){
                    head = nuevo;
                    cantidad++;
                }else{
                    Nodo* r = head;
                    while(r->get_siguiente()!=p){
                        r = r->get_siguiente();
                    }
                    
                    if(p==NULL){
                        r->set_siguiente(nuevo);
                    }else{
                        nuevo->set_siguiente(r->get_siguiente());
                        r->set_siguiente(nuevo);
                    }
                }
            }
        }
        
        Posicion fin(){
            Nodo *r = head;
            while(r->get_siguiente()!=NULL){
                r = r->get_siguiente();
            }return r;
        }
        
        Posicion primero(){
            if(head!=NULL){
                return head;
            }else{
                return fin();
            }
        }
        
        Posicion siguiente(Posicion p){
            return p->get_siguiente();
        }
        
        char acceder(Posicion p){
            return p->get_orden();
        }
        
        bool esVacia(){
            return head==NULL;
        }
};
 
//CAMBIA EL STRING DE C++ POR LA IMPLEMENTACION DE TU STRING, ES DECIR CAMBIALO POR MYSTRING
class Vehiculo{
    public:
    string placa;
    char puerta;
    int averiado;
    int contador;
    char *Item;
    Vehiculo *siguiente;
    public:
        Vehiculo(char placa, char puerta, int averiado){
            this->placa = placa;//this es un puntero que se referencia a si mismo, es decir a mi clase! 
            this->puerta = puerta;
            this->averiado = averiado;
        }
        
        string get_placa(){
            return placa;
        }
        
        char get_puerta(){
            return puerta;
        }
        
        int get_averiado(){
            return averiado;
        }
};
 
class Cola{
    class Nodo{
        Vehiculo *v;
        Nodo *siguiente;
        public:
            Nodo(Vehiculo *v){
                this->v = v;
                siguiente = NULL;
            }
            
            Vehiculo* get_v(){
                return v;
            }
            
            void set_siguiente(Nodo *n){
                siguiente = n;
            }
            
            Nodo* get_siguiente(){
                return siguiente;
            }
    };
    
    Nodo *pri, *ult;
    public:
        Cola(){
            pri = ult = NULL;
        }
        
        Vehiculo* primero(){
            return pri->get_v();
        }
        
        void encolar(Vehiculo* v){
            Nodo *nuevo = new Nodo(v);
            if(ult==NULL){
                pri = ult = nuevo;
            }else{
                ult->set_siguiente(nuevo);
                ult = nuevo;
            }
        }
        
        void desencolar(){
            Nodo *aux = pri;
            pri = pri->get_siguiente();
            delete aux;
            if(pri==NULL)
                ult = NULL;
        }
        
        bool esVacia(){
            return pri==NULL;
        }
};
 
 
class myString{
    public:
        Lista *primero;
        Lista *ultimo;
        Lista *aux;
        int contador;
        
    public:
        myString(){;
            primero = NULL;
            ultimo = NULL;
            aux = NULL;
            contador = 0;
}
 
    void Insertar (char c);
    void Mostrar ();
    
};
 
 void myString::Insertar(char aux){
 
    Lista* nuevo= new Lista();
    nuevo->caracter=aux; 
    if(primero==NULL && ultimo==NULL){
        primero=nuevo;
        ultimo=nuevo;
    }else{
        ultimo->siguiente=nuevo;
        ultimo=nuevo;
        contador++; //revisar no estoy segura de si hace falta
    }
};
 
void myString::Mostrar(char aux){
    aux=primero;
    do{
    cout<<aux->caracter;
    aux=aux->siguiente;
    }while(aux!=NULL);
    
};
 
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Repuestos{ //Pila donde voy a guardar los Repuestos
    public:
        Vehiculo *ultimo;
        Vehiculo *aux;
        Vehiculo *tope;
        int contador;//cantidad de carros que entran
        public:
        Repuestos(){
            tope=NULL;
            contador=0;
            ultimo=NULL;
            aux=NULL;
        }
        void Insertar(char placa[], char puerta, char averiado, char* item, int contador); 
        void Reparar(int i);
        void Mostrar(char c);
    void Usados(int i);
};
 
void Repuestos::Usados(char placa[], char puerta, char averiado ,char* item,int contador){// FALTA por resolver!!!!!!!!!!!!
 
    int Ing=Capital;
    int egreso=0;
    int ingreso=0;
    int c;
    
    
    if(ultimo->averiado=='0'){ // se repara y factura a la vez
        
            egreso=((ultimo->contador)*1); //Contador indica la cantidad de repuestos a reparar en el carro que esta siendo atendido
            ingreso=((ultimo->contador)*0);
            Capital +=(ingreso-egreso); //Indica la ganancia obtenida por Liam tras la reparacion del carro atendido
            
        };
         
    aux=ultimo;
    ultimo=aux->siguiente;//eliminacion del carro: se libera el nodo
    cout<<"Vehiculo "<<i<<": ";
    
    for(k=0;k<10;k++)
    {
        cout<<aux->placa[k];
    }
    cout<<"\n"<<-1*(egreso)<<"\n"<<ingreso<<endl;
    
    //apilamos FALTA POR REVISAR Y TERMINAR DE HACER!!!!
 
    Vehiculo *aux
    aux->siguiente=ultimo;
    ultimo=aux;
};
 
 
 
 
void Repuestos::Insertar(char placa[], char puerta, char averiado ,char* item,int contador){
  Vehiculo* nuevo=new Vehiculo();
   int k=0;
   
   for(k=0;k<10;k++){
        nuevo->placa[k]=placa[k];
    };
    
   nuevo->puerta = puerta;
   nuevo->averiado = averiado;
   nuevo->Item = item;  
   nuevo->contador = contador;
    //se empiezan ha armar los Repuestos
    if(ultimo==NULL){
        ultimo=nuevo;
    }else{
        nuevo->siguiente=ultimo;
        ultimo=nuevo;
    };  
    
    contador++; //cantidad de carros
};
 
void Repuestos::Mostrar(){ //Muestra la placa del ultimo carro en insertar repuestos 
    int k=0;
    for(k=0;k<10;k++){
        cout<<aux->placa[k];
    }   
};
    
void Repuestos::Reparar(int i){
 
    int Ing=Capital;
    int egreso=0;
    int ingreso=0;
    int k;
    
    
    if(ultimo->averiado=='1'){ // se repara y factura a la vez
        
            egreso=((ultimo->contador)*2); //Contador indica la cantidad de repuestos a reparar en el carro que esta siendo atendido
            ingreso=((ultimo->contador)*3);
            Capital +=(ingreso-egreso); //Indica la ganancia obtenida por Liam tras la reparacion del carro atendido
            
        
    }else if((Ing-ultimo->contador)>0){ //si averiado es igual a cero verificamos si tenemos capital para comprar
            Capital-=ultimo->contador; //en caso de que el capital sea positivo, se pueda comprar.Se realiza una sustraccion al ingreso ingreso neto de Liam
            egreso=ultimo->contador;
        };
         
    aux=ultimo;
    ultimo=aux->siguiente;//eliminacion logica
    cout<<"Vehiculo "<<i<<": ";
    
    for(k=0;k<10;k++)
    {
        cout<<aux->placa[k];
    }
    cout<<"\n"<<-1*(egreso)<<"\n"<<ingreso<<endl;
     
     //desapilamos
 
    delete(aux);//eliminacion del carro atendido
};
 
// MENU PRINCIPAL DEL PROGRAMA
int main(){
    int n,i,k;
    char *c=NULL;//entrada
    char placa[10];
    char puerta;
    char averiado;
    char aux;
    char *items=NULL;
    Repuestos A;
    Repuestos B;
    myString string;
    
    cin>>n; //cantidad de vehiculos a ingresar
    cin.ignore(); 
    for(i=0;i<n;i++)
    {
        fflush(stdin); //fflush limpia el buffer de entrada de datos, sirve para cuando se necesita tomar muchos datos seguidos y se generan saltos de línea automáticos que se guardan en este buffer
        c=new char[15];
        cin.getline(c,15); 
        k=0;
        do{
            placa[k]=*c;     //calcula la cantidad de atributos necesarios para la placa
            k++; c++;        //placa
        }while(*c!=' ');
        
        while(k<10){
            placa[k]=' '; //si la placa posee menos de 10 elementos alfanumericos,se completan los espacios con "vacio"
            k++;
        }    
            
        puerta=(*(c+1)); //calcula el atributo: puerta
        averiado=(*(c+3));  //calcula el atributo: averiado     
    
        
        fflush(stdin); //fflush limpia el buffer de entrada de datos, sirve para cuando se necesita tomar muchos datos seguidos y se generan saltos de línea automáticos que se guardan en este buffer
        items=new char[1002];
        cin.getline(items,1002);
        k=cantidadItems(items);
        if(puerta=='A' || puerta=='a') //Insertamos teniendo en cuenta la puerta
        {
            A.Insertar(placa,puerta,averiado,items,k); 
            
        }
        else if(puerta=='B' || puerta=='b')
        {
            B.Insertar(placa,puerta,averiado,items,k);
            
        }
    }   
    for(i=0;i<n;i++){
        cin>>aux;
        string.Insertar(aux);
    }
    string.aux=string.primero;
    for(i=0;i<n;i++){
        if(string.aux->caracter=='A' || string.aux->caracter=='a'){
            if(A.ultimo!=NULL){
                A.Reparar(i+1);
                
            }else{
                B.Reparar(i+1); 
                
            }   
        }else if(puerta=='B' || puerta=='b'){
            if(B.ultimo!=NULL){
                B.Reparar(i+1);
                
            }else{
                A.Reparar(i+1);
            
                }   
        }
        string.aux=string.aux->siguiente;
    }
    cout<<Capital<<endl;
return 0;
};
 

[starfix]

uno de los errores que veo es que el prototipo de algunas funciones no coinciden con el prototipo a la hora de declararlas. por ejemplo:


en la clase Repuestos tenes declarada la funcion void Usados(int i); y cuando queres desarrollar el algoritmo de esta funcion declaras void Respuestos::Usados(char placa[], char puerta, char averiado, char* item, int contador), para que la funcion sea correcta estos dos deben coincidir..... tendrias que cambiar la linea 261 por void Usados(char placa[], char puerta, char averiado, char* item, int contador Ó void Usados(char [], char, char, char*, int). Haciendo esto te va a dar error la linea 282 ya que tu variable i va a desaparecer.




Otro. en la funcion de la linea 234 myString::Mostrar(char aux). Dentro de esta estas tratando a la variable aux como si fuera un puntero, pero no la pasaste como puntero, una posible solucion seria agregar en el prototipo el asteriscto.
myString::Mostrar(char *aux)

si no la queres tratar como puntero tendrias que cambiar el codigo dentro de la funcion.



Otro. Linea 292 te olvidaste del ; por lo que te da un error en la siguiente linea diciendo que se esperaba la inicializacion de la variable aux.

Otro. linea 235, estas tratando de asignar a una variable de tipo char una de tipo Lista. Ahi no se que solucion darte porque no se que querias asignar.


sigo viendo tu codigo, saludos

[pyromiyuve]

Muchas gracias por la ayuda! La funcion void Usados no la he desarrollado en si todavia, por ahora tengo es solo ideas metidas dentro, se supone que en esa funcion voy a guardar en una pila los repuestos usados (items) que me entran con el vehiculo no averiado, para poder utilizarlos en el futuro para la reparacion de los vehiculas averiados, pero no se todavia como crear esa funcion para que haga lo que quiero.

No sabia lo de pasar *aux como puntero, con razon me daba error en la 234, y en la 235 el error fue mio, le debia asignar el primer caracter de MyString para mostrarlo, gracias por señalarmelo.

[pyromiyuve]

Elimine la clase myString::Mostrarr y cree la clase Caracter., pero me sigue dando error en la funcion void myString::Insertar cuando compilo, siendo la clase Vehiculos la que me da la mayoria de los errores....Mi nuevo codigo del proyecto es este:

Código C++:

#include<stdio.h>
#include<iostream>
using namespace std;
 
//Variables Globales
 
int Capital=20; 
 
int cantidadItems(char* c){ //Funcion que devuelve un Entero y se encarga de calcula cuantos repuestos disponemos
    int i=0;int k=0;
    do{
        if(*(c+i)==' '){
            k++;
        }
        i++;
    }while(*(c+i)!=('\0'));
    
    return(k+1);
};
 
int cant(char* c, int k){
    do{
        k++;
    }while((*(c+k)!=('\0')) && (*(c+k)!=(' ')));
    
    return(k);
};
 
//LISTA DE ORDEN
class Lista{
    class Nodo{
        char orden;
        Nodo *siguiente;
        public:
            Nodo(char orden){
                this->orden = orden;
                siguiente = NULL;
            }
            
            char get_orden(){
                return orden;
            }
            
            void set_siguiente(Nodo *n){
                siguiente = n;
            }
            
            Nodo* get_siguiente(){
                return siguiente;
            }
    };
    
    Nodo *head;
    int cantidad;
    typedef Nodo* Posicion;
    public:
        Posicion p;
        char caracter;
        Lista(){
            head = NULL;
            cantidad = 0;
        }
        
        void insertar(Posicion p, char orden){
            Nodo *nuevo = new Nodo(orden);
            if(nuevo!=NULL){//COMPRUEBO QUE HAYA MEMORIA
                if(head==NULL){
                    head = nuevo;
                    cantidad++;
                }else{
                    Nodo* r = head;
                    while(r->get_siguiente()!=p){
                        r = r->get_siguiente();
                    }
                    
                    if(p==NULL){
                        r->set_siguiente(nuevo);
                    }else{
                        nuevo->set_siguiente(r->get_siguiente());
                        r->set_siguiente(nuevo);
                    }
                }
            }
        }
        
        Posicion fin(){
            Nodo *r = head;
            while(r->get_siguiente()!=NULL){
                r = r->get_siguiente();
            }return r;
        }
        
        Posicion primero(){
            if(head!=NULL){
                return head;
            }else{
                return fin();
            }
        }
        
        Posicion siguiente(Posicion p){
            return p->get_siguiente();
        }
        
        char acceder(Posicion p){
            return p->get_orden();
        }
        
        bool esVacia(){
            return head==NULL;
        }
};
 
//CAMBIA EL STRING DE C++ POR LA IMPLEMENTACION DE TU STRING, ES DECIR CAMBIALO POR MYSTRING
class Vehiculo{
    public:
    string placa;
    char puerta;
    int averiado;
    int contador;
    char *Item;
    Vehiculo *siguiente;
    public:
        Vehiculo(char placa, char puerta, int averiado, char *Item){
            this->placa = placa;//this es un puntero que se referencia a si mismo, es decir a mi clase! 
            this->puerta = puerta;
            this->averiado = averiado;
            this ->Item = Item;
            contador=0;
        }
        
        string get_placa(){
            return placa;
        }
        
        char get_puerta(){
            return puerta;
        }
        
        int get_averiado(){
            return averiado;
        }
        char* get_Item(){
            return Item;
        }
        
        
};
 
class Cola{
    class Nodo{
        Vehiculo *v;
        Nodo *siguiente;
        public:
            Nodo(Vehiculo *v){
                this->v = v;
                siguiente = NULL;
            }
            
            Vehiculo* get_v(){
                return v;
            }
            
            void set_siguiente(Nodo *n){
                siguiente = n;
            }
            
            Nodo* get_siguiente(){
                return siguiente;
            }
    };
    
    Nodo *pri, *ult;
    public:
        Cola(){
            pri = ult = NULL;
        }
        
        Vehiculo* primero(){
            return pri->get_v();
        }
        
        void encolar(Vehiculo* v){
            Nodo *nuevo = new Nodo(v);
            if(ult==NULL){
                pri = ult = nuevo;
            }else{
                ult->set_siguiente(nuevo);
                ult = nuevo;
            }
        }
        
        void desencolar(){
            Nodo *aux = pri;
            pri = pri->get_siguiente();
            delete aux;
            if(pri==NULL)
                ult = NULL;
        }
        
        bool esVacia(){
            return pri==NULL;
        }
};
 
class Caracter{
 
    public:
 
    char caracter;
 
    Caracter* sig;
 
    public:
 
    Caracter(){
 
        sig=NULL;
 
    }   
 
};
 
class myString{
    public:
        Caracter *primero;
        Caracter *ultimo;
        Caracter *aux;
        int contador;
        
    public:
        myString(){;
            primero = NULL;
            ultimo = NULL;
            aux = NULL;
            contador = 0;
}
 
    void Insertar (char c);
    
};
 
 void myString::Insertar(char c){
 
    Caracter* nuevo= new Caracter();
    nuevo->caracter=aux; 
    if(primero==NULL && ultimo==NULL){
        primero=nuevo;
        ultimo=nuevo;
    }else{
        ultimo->sig=nuevo;
        ultimo=nuevo;
        contador++; //revisar no estoy segura de si hace falta
    }
};
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Repuestos{ //Pila donde voy a guardar los Repuestos
    public:
        Vehiculo *ultimo;
        Vehiculo *aux;
        Vehiculo *tope;
        int contador;//cantidad de carros que entran
        public:
        Repuestos(){
            tope=NULL;
            contador=0;
            ultimo=NULL;
            aux=NULL;
        }
        void Insertar(char placa[], char puerta, char averiado, char* item, int contador); 
        void Reparar(int i);
        void Mostrar(int i);
    void Usados(int i);
};
 
void Repuestos::Usados(char placa[], char puerta, char averiado ,char* item,int contador){// FALTA por resolver!!!!!!!!!!!!
 
    int Ing=Capital;
    int egreso=0;
    int ingreso=0;
    int c;
    
    
    if(ultimo->averiado=='0'){ // se repara y factura a la vez
        
            egreso=((ultimo->contador)*1); //Contador indica la cantidad de repuestos a reparar en el carro que esta siendo atendido
            ingreso=((ultimo->contador)*0);
            Capital +=(ingreso-egreso); //Indica la ganancia obtenida por Liam tras la reparacion del carro atendido
            
        };
         
    aux=ultimo;
    ultimo=aux->siguiente;//eliminacion del carro: se libera el nodo
    cout<<"Vehiculo "<<i<<": ";
    
    for(k=0;k<10;k++)
    {
        cout<<aux->placa[k];
    }
    cout<<"\n"<<-1*(egreso)<<"\n"<<ingreso<<endl;
    
    //apilamos FALTA POR REVISAR Y TERMINAR DE HACER!!!!
 
    Vehiculo *aux;
    aux->siguiente=ultimo;
    ultimo=aux;
};
 
 
 
 
void Repuestos::Insertar(char placa[], char puerta, char averiado ,char* item,int contador){
  Vehiculo* nuevo=new Vehiculo();
   int k=0;
   
   for(k=0;k<10;k++){
        nuevo->placa[k]=placa[k];
    };
    
   nuevo->puerta = puerta;
   nuevo->averiado = averiado;
   nuevo->Item = item;  
   nuevo->contador = contador;
    //se empiezan ha armar los Repuestos
    if(ultimo==NULL){
        ultimo=nuevo;
    }else{
        nuevo->siguiente=ultimo;
        ultimo=nuevo;
    };  
    
    contador++; //cantidad de carros
};
 
void Repuestos::Mostrar(int i){ //Muestra la placa del ultimo carro en insertar repuestos 
    int k;
    for(k=0;k<10;k++){
        cout<<aux->placa[k];
    }   
};
    
void Repuestos::Reparar(int i){
 
    int Ing=Capital;
    int egreso=0;
    int ingreso=0;
    int k;
    
    
    if(ultimo->averiado=='1'){ // se repara y factura a la vez
        
            egreso=((ultimo->contador)*2); //Contador indica la cantidad de repuestos a reparar en el carro que esta siendo atendido
            ingreso=((ultimo->contador)*3);
            Capital +=(ingreso-egreso); //Indica la ganancia obtenida por Liam tras la reparacion del carro atendido
            
        
    }else if((Ing-ultimo->contador)>0){ //si averiado es igual a cero verificamos si tenemos capital para comprar
            Capital-=ultimo->contador; //en caso de que el capital sea positivo, se pueda comprar.Se realiza una sustraccion al ingreso ingreso neto de Liam
            egreso=ultimo->contador;
        };
         
    aux=ultimo;
    ultimo=aux->siguiente;//eliminacion logica
    cout<<"Vehiculo "<<i<<": ";
    
    for(k=0;k<10;k++)
    {
        cout<<aux->placa[k];
    }
    cout<<"\n"<<-1*(egreso)<<"\n"<<ingreso<<endl;
     
     //desapilamos
 
    delete(aux);//eliminacion del carro atendido
};
 
// MENU PRINCIPAL DEL PROGRAMA
int main(){
    int n,i,k;
    char *c=NULL;//entrada
    char placa[10];
    char puerta;
    char averiado;
    char aux;
    char *items=NULL;
    char orden;
    Repuestos A;
    Repuestos B;
    Vehiculo *v;
    myString string;
    
    Cola *puertaA = new Cola(), *puertaB = new Cola();
 
    Lista *lorden = new Lista();
 
    cin>>n; //cantidad de vehiculos a ingresar
    cin.ignore(); 
    for(i=0;i<n;i++)
    {
        fflush(stdin); //fflush limpia el buffer de entrada de datos, sirve para cuando se necesita tomar muchos datos seguidos y se generan saltos de línea automáticos que se guardan en este buffer
        c=new char[15];
        cin.getline(c,15); 
        k=0;
        do{
            placa[k]=*c;     //calcula la cantidad de atributos necesarios para la placa
            k++; c++;        //placa
        }while(*c!=' ');
        
        while(k<10){
            placa[k]=' '; //si la placa posee menos de 10 elementos alfanumericos,se completan los espacios con "vacio"
            k++;
        }    
            
        puerta=(*(c+1)); //calcula el atributo: puerta
        averiado=(*(c+3));  //calcula el atributo: averiado     
    
        
        fflush(stdin); //fflush limpia el buffer de entrada de datos, sirve para cuando se necesita tomar muchos datos seguidos y se generan saltos de línea automáticos que se guardan en este buffer
        items=new char[1002];
        cin.getline(items,1002);
        k=cantidadItems(items);
        v = new Vehiculo(placa,puerta,averiado);
 
        if(puerta=='A' || puerta=='a') //Insertamos teniendo en cuenta la puerta
        {
                
            puertaA->encolar(v); 
 
            A.Insertar(placa,puerta,averiado,items,k);
        
            
        }
        else if(puerta=='B' || puerta=='b')
        {           
            
            puertaB->encolar(v);
 
            B.Insertar(placa,puerta,averiado,items,k);
            
        }
    }   
    for(i=0;i<n;i++){
        cin>>aux;
        string.Insertar(aux);
    }
    string.aux=string.primero;
    for(i=0;i<n;i++){
 
        lorden->insertar(NULL,orden);
 
        if(string.aux->caracter=='A' || string.aux->caracter=='a'){
            if(A.ultimo!=NULL){
                A.Reparar(i+1);
                
            }else{
                B.Reparar(i+1); 
                
            }   
        }else if(puerta=='B' || puerta=='b'){
            if(B.ultimo!=NULL){
                B.Reparar(i+1);
                
            }else{
                A.Reparar(i+1);
            
                }   
        }
        string.aux=string.aux->sig;
    }
    cout<<Capital<<endl;
 
    delete puertaA, puertaB, v, lorden;
return 0;
};
 

Saludos

[starfix]

Solucionesmos los ultimos errores para que el programa compile y luego analizamos la logica del programa.


LINEA 246:

Estas tratando de asignar a una variable de tipo char un puntero de tipo Caracter.

Otra vez no se que asignacion querés hacer.


LINEA 274:

Cambiarla por:

Código C++:

void Repuestos::Usados(char placa[], char puerta, char averiado ,char* item,int contador);
 

este error surge al no coincider el prototipo de la funcion en esta linea y la 277.


LINEA 295:

Eliminarla, no va a ser necesaria en el futuro, lo vamos a solucionar de otra manera.


LINEA 297:

La variable k que utilizas dentro del for no fue previamente declarada, para solucionar esto podes declararla dentro del for:

Código C++:

for (int k=0; k<10; k++)
 

LINEA 314:

La clase Vehiulo cuenta con un constructo:

Código C++:

Vehiculo(char placa, char puerta, int averiado, char *Item);
 

al crear una variable de este tipo tenes que pasarle como parametro 4 variables de tipo char, char, int y char* respectivamente.

Solucion:

Código C++:

int AELiminar;//esta variable la cree para utilzarla en el constructos de la linea que sigue 
                     //ya que necesita una variable de tipo int que no hay
 
Vehiculo* nuevo= new Vehiculo(*placa, puerta, AEliminar, item);
 

LINEA 423:

nuevamente el mismo error anterior, cuando creas una variable de tipo Vehiculo tenes que pasarle 4 variables:

Código C++:

v = new Vehiculo(*placa,puerta,averiado, items);
 

Ahora el programa compila y como te dije anteriormente hay que buscar los problemas de logica y terminar la funciones incompletas.

Saludos y felices fiesta.