Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Visual C++ .NET » Lista en C, ayuda con un error durante la compilación

Visual C++ .NET - Lista en C, ayuda con un error durante la compilación

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 1
Ha aumentado su posición en 4 puestos en Visual C++ .NET (en relación al último mes)
Gráfica de Visual C++ .NET

Lista en C, ayuda con un error durante la compilación

Publicado por Allan (1 intervención) el 21/03/2019 01:51:05
Hola gente de LWP

Tengo una lista que yo mismo cree como librería, ya la he usado en otros proyectos, he implementado la misma funcionalidad en otros proyecto y funciona muy bien, pero ahora no se porque me paso esto,
el problema es que me arroja un error de que no puede convertir lo que le mando al objeto plantilla ó algo así
cada vez que soluciono un error me arroja otro, entones no comprendo que podrá estar pasando, agradezco su ayuda desde ya.

Dejo el código de la lista y dónde lo estoy implementando

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
//---------- Código de AList.h

 
#ifndef ALIST_H

#define ALIST_H

#define NULL 0x0

template <class T>
class AList{
private:
    //************* Estructura que almacena la lista **********************//

    struct Nodo{
        T objeto;
        unsigned int pos = 0;
        Nodo *sig;
    };
    Nodo *lista;
    //*********************************************************************//

    void insertar_inicio_private(Nodo *&lista,T objeto);
    void insertar_final_private(Nodo *&lista, T objeto);
    void borrar_at_private(Nodo *&lista, unsigned int pos);
    unsigned int tamano;
public:
    AList();
    AList(T objeto);
    //*************************************************************************//

    //**************************** Funciones publicas *************************//

    void insertar(T objeto);
    void insertar_final(T objeto);
    T obtener_at(unsigned int pos);
    void borrar_at(unsigned int pos);
    void borrar_todosElementos();
    unsigned int get_tamano();
    void reemplazar(T objeto,unsigned int pos);
    //*************************************************************************//

    //*************************************************************************//

 
    //*************************************************************************//

    //**************************** Operadores *********************************//

    AList<T> operator=(AList<T> lista);
    T operator[](const unsigned int indice);
    //*************************************************************************//

    //*************************************************************************//

};
 
template <class T>
AList<T>::AList(){
    this->lista = NULL;
    this->tamano = 0;
}
 
template<class T>
AList<T>::AList(T objeto){
    this->lista = NULL;
    this->tamano = 0;
    this->insertar_inicio_private(this->lista,objeto);
    this->tamano++;
}
 
template<class T>
void AList<T>::insertar(T objeto){
    this->insertar_inicio_private(this->lista,objeto);
    this->tamano++;
}
 
template<class T>
void AList<T>::insertar_inicio_private(Nodo *&lista, T objeto){
    Nodo *p = new(struct Nodo);
    p->objeto = objeto;
    p->pos = tamano + 1;
    p->sig = lista;
    lista = p;
}
 
template<class T>
void AList<T>::insertar_final(T objeto){
    this->insertar_final_private(this->lista,objeto);
    this->tamano++;
}
 
template <class T>
void AList<T>::insertar_final_private(Nodo *&lista, T objeto){
    Nodo *p = new(struct Nodo), *aux;
    p->objeto = objeto;
    p->pos = this->tamano + 1;
    p->sig = lista;
 
    if(lista == NULL){
        lista = p;
    }
    else{
        aux = lista;
        while(aux->sig != NULL){
            aux = aux->sig;
        }
        aux->sig = p;
    }
}
 
template <class T>
T AList<T>::obtener_at(unsigned int pos){
    T objeto_nulo;
 
    if(pos > this->tamano){
        return objeto_nulo;
    }
    else
    if(this->lista == NULL){
        return objeto_nulo;
    }
    else{
        Nodo *aux = this->lista;
        unsigned int i = 0;
        while(aux != NULL){
            if(i == pos){
                return aux->objeto;
            }
            i++;
            aux = aux->sig;
        }
 
        return objeto_nulo;
    }
}
 
template <class T>
void AList<T>::borrar_at(unsigned int pos){
    this->borrar_at_private(this->lista,pos);
}
 
template <class T>
void AList<T>::borrar_at_private(Nodo *&lista, unsigned int pos){
    Nodo *p, *ant;
    p = lista;
 
    if(pos > this->tamano){
        return;
    }
    else{
        if(lista != NULL){
            unsigned int i = 0;
            while(p != NULL){
                if(i == pos){
                    if(p == lista){
                        lista = lista->sig;
                    }
                    else{
                        ant->sig = p->sig;
                    }
 
                    delete(p);
                    this->tamano -= 1;
                    return;
                }
                ant = p;
                p->pos = i;
                p = p->sig;
                i++;
            }
        }
        else{
            return;
        }
    }
}
 
template<class T>
unsigned int AList<T>::get_tamano(){return this->tamano;}
 
template<class T>
void AList<T>::reemplazar(T objeto,unsigned int pos){
    if(pos > this->tamano){
        return;
    }
    else{
        Nodo *p, *ant;
        p = this->lista;
 
        if(this->lista != NULL){
            int i = -1;
            while(p != NULL){
                if(i == pos){
                    ant->objeto = objeto;
                    return;
                }
                ant = p;
                p->pos = i;
                p = p->sig;
                i++;
            }
        }
        else{
            return;
        }
    }
}
 
template<class T>
void AList<T>::borrar_todosElementos(){
    if(this->lista == NULL){
        return;
    }
    else{
        Nodo *aux = this->lista;
        while(aux != NULL){
            aux = this->lista;
            if(lista != NULL){
                lista = aux->sig;
            }
            delete(aux);
        }
        this->tamano = 0;
    }
}
 
template<class T>
AList<T> AList<T>::operator=(AList<T> lista){
    if(lista.get_tamano() > 0){
        this->borrar_todosElementos();
        for(unsigned int i = 0; i < lista.get_tamano(); i++){
            this->insertar(lista.obtener_at(i));
        }
        return this;
    }
    else{
        this->borrar_todosElementos();
        return this;
    }
}
 
template<class T>
T AList<T>::operator[](const unsigned int indice){
    T objeto_nulo;
 
    if(indice > this->tamano){
        return objeto_nulo;
    }
    else
    if(this->lista == NULL){
        return objeto_nulo;
    }
    else{
        Nodo *aux = this->lista;
        unsigned int i = 0;
        while(aux != NULL){
            if(i == indice){
                return aux->objeto;
            }
            i++;
            aux = aux->sig;
        }
 
        return objeto_nulo;
    }
}
#endif // ALIST_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
//---------------- Código dónde lo estoy implementando

 
#ifndef PROYECTO_CIA_H

#define PROYECTO_CIA_H

#include "../AList.h"

#include <iostream>

 
using namespace std;
 
class Proyecto_cia
{
    private:
 
        struct Datos{
                char nombre_proyecto[255];
                char ruta_proyecto[2048];
                const short int codigo_archivos = 1;
                int num_archivos_incluidos;
            };
 
        struct Archivos{
            char nombre_archivo[255];
            char ruta_archivo[2048];
            int codigo_archivo;
            const short int codigo_archivos = 1;
        };
 
        Datos datos;
        Archivos archivos;
        AList<Archivos> lista_archivos;
        AList<Datos> lista_datos;
        FILE *archi;
 
        /*'''''''''''''''''''''''''' Funciones privada '''''''''''''''''''''''''''''''''''*/
        int obtener_siguienteCodigoArchivo(const char* nombreArchivo);
        /*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
    public:
        Proyecto_cia();
        virtual ~Proyecto_cia();
 
        std::string get_nombreArchivo();
        std::string get_rutaArchivo();
        bool nuevo_proyecto(const char* nombre_proyecto, const char* nombre_archivo, const char* directorio);
        AList<Archivos> get_list_archivos();
        AList<Datos> get_list_datos_archivos();
        //''''''''''''''''''''''''' Enumeracion para buscar listas ''''''''''''''''''''''''''''''''''''''''''

        enum TiposListas{
            LISTA_ARCHIVOS,
            LISTA_DATOS
        };
        //'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

 
};
 
#endif // PROYECTO_CIA_H

 
 
#define ARCHI_ESCRITURA_BINARIA "rb+"

#define ARCHI_LECTURA_BINARIA "rb"

#define CREAR_ARCHIVO "a"

#define ARCHI_ESCRITURA_TEXTO_PLANO "a+t"

 
 
#include "Proyecto_cia.h"

#include <fstream>

#include <iostream>

#include <windows.h>

#include <stdio.h>

#include <conio.h>

#include <ctype.h>

#include <stdlib.h>

#include <cstring>

#include <string>

#include <io.h>

 
//using namespace std;

 
Proyecto_cia::Proyecto_cia()
{
    //ctor

}
 
Proyecto_cia::~Proyecto_cia()
{
    //dtor

}
 
/*''''''''''''''''''''''''''''''''' Funciones publicas '''''''''''''''''''''''''''''''''''''''''''''''*/
 
int Proyecto_cia::obtener_siguienteCodigoArchivo(const char* nombreArchivo){
    archi = fopen(nombreArchivo,ARCHI_LECTURA_BINARIA);
 
    if(archi == NULL){
        fclose(archi);
        return -1;
    }
    else{
        unsigned int codigo = 0;
        fseek(archi,0,SEEK_SET);
        fread(&archivos,sizeof(archivos),1,archi);
        while(!feof(archi)){
            codigo = archivos.codigo_archivo + 1;
            fread(&archivos,sizeof(archivos),1,archi);
        }
 
        fclose(archi);
        return codigo;
    }
}
 
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
 
/*''''''''''''''''''''''''''''''''' Funciones publicas '''''''''''''''''''''''''''''''''''''''''''''''*/
std::string Proyecto_cia::get_nombreArchivo(){
    char buffer[MAX_PATH];
    GetModuleFileName(NULL, buffer, MAX_PATH);
    return std::string(buffer);
}
 
std::string Proyecto_cia::get_rutaArchivo(){
    std::string archivo = this->get_nombreArchivo();
    return archivo.substr(0,archivo.find_last_of("\\/"));
}
 
bool Proyecto_cia::nuevo_proyecto(const char* nombre_proyecto, const char* nombre_archivo, const char* directorio){
 
    string archivo_completo(directorio);
    archivo_completo += string("/") + string(nombre_proyecto);
 
    archi = fopen(archivo_completo.c_str(), CREAR_ARCHIVO);
    fclose(archi);
 
    this->archi = fopen(archivo_completo.c_str(), ARCHI_ESCRITURA_BINARIA);
 
    if(this->archi == NULL){
        fclose(archi);
        return false;
    }
 
    strcpy(datos.ruta_proyecto,directorio);
    strcpy(datos.nombre_proyecto,nombre_proyecto);
    datos.num_archivos_incluidos = 1;
    strcpy(archivos.nombre_archivo,nombre_archivo);
    strcpy(archivos.ruta_archivo,directorio);
    archivos.codigo_archivo = 1;
 
    fwrite(&datos, sizeof(datos),1,archi);
    fclose(archi);
 
    this->archi = fopen(archivo_completo.c_str(), ARCHI_ESCRITURA_BINARIA);
 
    if(this->archi == NULL){
        fclose(archi);
        archi = fopen(archivo_completo.c_str(), CREAR_ARCHIVO);
        fclose(archi);
        return false;
    }
 
    fwrite(&archivos, sizeof(archivos), 1, archi);
    fclose(archi);
 
    string archivo_textoPlano(directorio);
    archivo_textoPlano += "/" + string(nombre_archivo);
    archi = fopen(archivo_textoPlano.c_str(),ARCHI_ESCRITURA_TEXTO_PLANO);
 
    const char* plantilla_codigo = "// Función principal \n \nprincipal(){ \n \t print(\"Hola mundo de CIA...\") \n \t system(\"pause\") \n }";
 
    fputs(plantilla_codigo,archi);
 
    fclose(archi);
 
    lista_archivos.insertar(archivos);
    lista_datos.insertar(datos);
 
    return true;
}
 
 
//****************** En estas dos ultimas funciones estoy teniendo problemas

//****************** Y me manda como que el error estuviera en AList.h

AList<Proyecto_cia::Archivos> Proyecto_cia::get_list_archivos(){
    return this->lista_archivos;
}
 
AList<Proyecto_cia::Datos> Proyecto_cia::get_list_datos_archivos(){
    return this->lista_datos;
}
 
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/

5c90654d3610b-codigo-error
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Rodrigo
Val: 7
Ha mantenido su posición en Visual C++ .NET (en relación al último mes)
Gráfica de Visual C++ .NET

Lista en C, ayuda con un error durante la compilación

Publicado por Rodrigo (2 intervenciones) el 22/05/2019 17:45:57
Cambia tus const por static const

Hay varios otros problemas con tu codigo de la lista, pero no tienen que ver con la compilacion.
creo que lo anterior es esencialmente lo que te esta reclamando el compilador.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar