Skip to content

Commit 6a3c9bb

Browse files
emmett1598emmett1598
committed
changes
1 parent e508ed5 commit 6a3c9bb

3 files changed

Lines changed: 361 additions & 0 deletions

File tree

‎code.c‎

Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
#include <stdio.h>
2+
#include <windows.h>
3+
#include "vector.h"
4+
5+
int main(int argc, char **argv)
6+
{
7+
8+
vector *my_vector = new_vector(10, sizeof(int));
9+
print_vector_info(my_vector);
10+
puts("=========");
11+
12+
resize(my_vector, 5);
13+
print_vector_info(my_vector);
14+
puts("=========");
15+
16+
size_t posicion1;
17+
for (int i = 0; i < 30; i++)
18+
{
19+
element_def_asg(int, n1, i)
20+
posicion1 = push_back(my_vector, n1) - 1;
21+
printf("%zu, %d\n", posicion1, get_elment(int, my_vector, posicion1));
22+
// print_vector_info(my_vector);
23+
}
24+
element_def_asg(float, n2, 10.5)
25+
posicion1 = push_back(my_vector, n2) - 1;
26+
27+
printf("%zu, %f\n", posicion1, get_elment(float, my_vector, posicion1));
28+
print_vector_info(my_vector);
29+
30+
posicion1 = pop_back(my_vector) -1;
31+
printf("%zu, %d\n", posicion1, get_elment(int, my_vector, posicion1));
32+
33+
printf("vectores sin usar: %d\n", vectores_sin_usar());
34+
printf("vectores reserbados: %d\n", vectores_reserbados());
35+
printf("vectores ocupados: %d\n", vectores_ocupados());
36+
printf("size de my_vector: %d\n", size(my_vector));
37+
printf("max_size de my_vector: %d\n", max_size(my_vector));
38+
printf("empty de my_vector: %d\n", empty(my_vector));
39+
40+
clear(my_vector);
41+
42+
return 0;
43+
}

‎vector.c‎

Lines changed: 247 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,247 @@
1+
#ifndef __VECTOR_C__
2+
#define __VECTOR_C__
3+
#include "vector.h"
4+
5+
void __attribute__((constructor)) __constructor_array_dinamic__()
6+
{
7+
printf("Constructor, vectores inicializados: %d, tamnos estructura vector: %lld\n", vectores_resb, sizeof(vector));
8+
tabla_vectores.tabla_vectores = (vector **)malloc(vectores_resb * sizeof(vector *));
9+
10+
for (size_t i = 0; i < vectores_resb; i++)
11+
{
12+
tabla_vectores.tabla_vectores[i] = (vector *)malloc(sizeof(vector));
13+
tabla_vectores.tabla_vectores[i]->size = 0;
14+
tabla_vectores.tabla_vectores[i]->plexor = 0;
15+
}
16+
}
17+
void __attribute__((destructor)) __destructor_array_dinamic__()
18+
{
19+
puts("Destructor");
20+
21+
if (tabla_vectores.tabla_vectores != NULL)
22+
{
23+
for (size_t i = 0; i < tabla_vectores.vectores_ocupados; i++)
24+
{
25+
if (tabla_vectores.tabla_vectores[i] != NULL)
26+
{
27+
free_vector(tabla_vectores.tabla_vectores[i]);
28+
}
29+
}
30+
free(tabla_vectores.tabla_vectores);
31+
}
32+
33+
puts("Memoria liberada");
34+
}
35+
36+
37+
void free_vector(vector *my_vector)
38+
{
39+
// liberar la memoria de un vector y su memoria asociada.
40+
for (size_t i = 0; i < my_vector->size; i++)
41+
{
42+
if (my_vector->data[i]->estado == true)
43+
{
44+
free(my_vector->data[i]->data);
45+
}
46+
free(my_vector->data[i]);
47+
}
48+
free(my_vector);
49+
}
50+
51+
vector *new_vector(size_t size, size_t size_data)
52+
{
53+
54+
tabla_vectores.vectores_ocupados++;
55+
if (tabla_vectores.vectores_reserbados <= tabla_vectores.vectores_ocupados)
56+
{
57+
tabla_vectores.vectores_reserbados *= incrementador_v;
58+
tabla_vectores.tabla_vectores = (vector **)realloc(tabla_vectores.tabla_vectores, sizeof(vector *) * tabla_vectores.vectores_reserbados);
59+
}
60+
61+
tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados] = (vector *)malloc(sizeof(vector));
62+
tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados]->data = (data_position **)malloc(sizeof(data_position *) * size_data);
63+
for (size_t i = 0; i < size; i++)
64+
{
65+
// poner las posiciones del vector inicializadas y marcarlas como libres(false)
66+
tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados]->data[i] = (data_position *)malloc(sizeof(data_position));
67+
tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados]->data[i]->estado = false;
68+
}
69+
tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados]->capacity = size;
70+
tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados]->size = 0;
71+
tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados]->plexor = size_data;
72+
73+
return tabla_vectores.tabla_vectores[tabla_vectores.vectores_ocupados];
74+
}
75+
76+
size_t push_back(vector *my_vector, void *data)
77+
{
78+
// anade un elemento al final del vector
79+
if (my_vector->size + 1 > my_vector->capacity)
80+
{
81+
// redimensionar si no hay espacio para anadir un nuevo elemento
82+
my_vector->capacity *= incrementador_v;
83+
resize(my_vector, my_vector->capacity);
84+
for (size_t i = my_vector->size; i < my_vector->capacity; i++)
85+
{
86+
// poner las posiciones del vector inicializadas y marcarlas como libres(false)
87+
my_vector->data[i] = (data_position *)malloc(sizeof(data_position));
88+
my_vector->data[i]->estado = false;
89+
}
90+
}
91+
my_vector->data[my_vector->size]->estado = true;
92+
my_vector->data[my_vector->size]->data = data;
93+
94+
// retornar la posicion donde se encuentra el elemento agregado actualmente:
95+
return ++my_vector->size;
96+
}
97+
98+
size_t pop_back(vector *my_vector)
99+
{
100+
if (my_vector->size > 0)
101+
{
102+
if (my_vector->data[my_vector->size]->estado == true)
103+
{
104+
// "elimina" el elemento al final del vector
105+
free(my_vector->data[my_vector->size]->data);
106+
// marcar como libre:
107+
my_vector->data[my_vector->size]->estado = false;
108+
}
109+
// retorna la posicicon del ultimo elemento
110+
return --my_vector->size;
111+
}
112+
return 0;
113+
}
114+
size_t size(vector *my_vector)
115+
{
116+
// retorna el tamano
117+
return my_vector->size;
118+
}
119+
size_t max_size(vector *my_vector)
120+
{
121+
// retorna el tamano maximo
122+
return my_vector->capacity;
123+
}
124+
size_t get_size_position(vector *my_vector)
125+
{
126+
// obtener el espacio de una posicion del vector
127+
return my_vector->plexor;
128+
}
129+
130+
size_t vectores_sin_usar()
131+
{
132+
return tabla_vectores.vectores_reserbados - tabla_vectores.vectores_ocupados;
133+
}
134+
size_t vectores_ocupados()
135+
{
136+
// retorna el tamano
137+
return tabla_vectores.vectores_ocupados;
138+
}
139+
size_t vectores_reserbados()
140+
{
141+
// retorna el tamano maximo
142+
return tabla_vectores.vectores_reserbados;
143+
}
144+
145+
void *get_elment_v(vector *my_vector, size_t posicion)
146+
{
147+
// obtener un elemento
148+
return my_vector->data[posicion]->data;
149+
}
150+
151+
bool empty(vector *my_vector)
152+
{
153+
if (my_vector->size - my_vector->capacity == 0)
154+
return true;
155+
else
156+
return false;
157+
}
158+
159+
void clear(vector *my_vector)
160+
{
161+
for (size_t i = 0; i < my_vector->size; i++)
162+
{
163+
if (my_vector->data[i]->estado == true)
164+
{
165+
free(my_vector->data[i]->data);
166+
}
167+
free(my_vector->data[i]);
168+
}
169+
170+
my_vector->size = 0;
171+
}
172+
173+
void resize(vector *my_vector, size_t size)
174+
{
175+
if (size == my_vector->capacity)
176+
{
177+
// No es necesario realizar cambios si el tamaño es el mismo
178+
return;
179+
}
180+
181+
if (size < my_vector->size)
182+
{
183+
// Liberar la memoria de las posiciones eliminadas
184+
for (size_t i = size; i < my_vector->size; i++)
185+
{
186+
if (my_vector->data[i]->estado == true)
187+
{
188+
free(my_vector->data[i]->data);
189+
}
190+
free(my_vector->data[i]);
191+
}
192+
my_vector->size = size;
193+
}
194+
195+
// Crear un nuevo bloque de memoria con el tamaño deseado
196+
data_position **new_data = (data_position **)malloc(sizeof(data_position *) * size);
197+
if (new_data == NULL)
198+
{
199+
// No se pudo asignar memoria, el vector no se modificará
200+
return;
201+
}
202+
203+
// Copiar los elementos existentes al nuevo bloque de memoria conservando el orden
204+
for (size_t i = 0; i < size; i++)
205+
{
206+
if (i < my_vector->size)
207+
{
208+
new_data[i] = my_vector->data[i];
209+
}
210+
else
211+
{
212+
// Crear nuevas estructuras data_position para las posiciones adicionales
213+
new_data[i] = (data_position *)malloc(sizeof(data_position));
214+
new_data[i]->estado = false;
215+
}
216+
}
217+
218+
// Liberar el bloque de memoria anterior
219+
free(my_vector->data);
220+
221+
my_vector->data = new_data;
222+
my_vector->capacity = size;
223+
}
224+
225+
226+
void print_vector_info(vector *my_vector)
227+
{
228+
printf("capacity: %zu\n", my_vector->capacity);
229+
printf("data: %p\n", my_vector->data);
230+
printf("size: %zu\n", my_vector->size);
231+
printf("plexor: %zu\n", my_vector->plexor);
232+
233+
for (size_t i = 0; i < my_vector->capacity; i++)
234+
{
235+
printf("data[%d]->data: \t%p \n", i, my_vector->data[i]);
236+
if (my_vector->data[i] == NULL)
237+
{
238+
printf("data[%d]->estado:\t%p\n", i, NULL);
239+
}
240+
else
241+
{
242+
printf("data[%d]->estado:\t%p\n", i, my_vector->data[i]->estado);
243+
}
244+
}
245+
}
246+
247+
#endif

‎vector.h‎

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
#ifndef __VECTOR_H__
2+
#define __VECTOR_H__
3+
#include <stdlib.h>
4+
#include <stdbool.h>
5+
6+
typedef struct data_position
7+
{
8+
bool estado; // posicion en uso = true
9+
void *data; // datos almacenado del vector
10+
} data_position;
11+
12+
typedef struct vector
13+
{
14+
size_t size; // tamaño de los datos, cantidad que se usa de capacity
15+
size_t capacity; // capacidad maxima del vector
16+
data_position **data; // datos almacenado del vector
17+
size_t plexor; // tamano de una posion en memoria
18+
} vector;
19+
20+
void __attribute__((constructor)) __constructor_array_dinamic__();
21+
void __attribute__((destructor)) __destructor_array_dinamic__();
22+
23+
vector *new_vector(size_t size, size_t size_data);
24+
void print_vector_info(vector *my_vector);
25+
size_t vectores_sin_usar();
26+
size_t size(vector *my_vector);
27+
size_t max_size(vector *my_vector);
28+
void resize(vector *my_vector, size_t size);
29+
void free_vector(vector *my_vector);
30+
void *get_elment_v(vector *my_vector, size_t posicion);
31+
size_t vectores_reserbados();
32+
size_t vectores_ocupados();
33+
size_t get_size_position(vector *my_vector);
34+
size_t pop_back(vector *my_vector);
35+
size_t push_back(vector *my_vector, void *data);
36+
bool empty(vector *my_vector);
37+
void clear(vector *my_vector);
38+
39+
// vectores iniciales a reserbar:
40+
#define vectores_resb 20
41+
// cantidad por la que multiplicar el nuevo tamano redimensionado:
42+
#define incrementador_v 2
43+
44+
// definicion:
45+
#define element_def(type, name) \
46+
type *name = (type *)malloc(sizeof(type));
47+
48+
// asignacion
49+
#define element_asg(name, value) \
50+
*name = value;
51+
52+
// definicion y asignacion:
53+
#define element_def_asg(type, name, value) \
54+
type *name = (type *)malloc(sizeof(type)); \
55+
*name = value;
56+
57+
#define get_elment(type, name, posicion) \
58+
*((type *)(get_elment_v(name, posicion)))
59+
60+
struct TableVector
61+
{
62+
vector **tabla_vectores; // punteros a cada vector dinamico
63+
size_t vectores_ocupados; // vectores usados
64+
size_t vectores_reserbados; // vectores reservados. vectores_resbados - vectores_ocupados = vectores no ocupados
65+
} tabla_vectores = {
66+
.tabla_vectores = NULL,
67+
.vectores_ocupados = 0,
68+
.vectores_reserbados = vectores_resb};
69+
70+
#include "vector.c"
71+
#endif

0 commit comments

Comments
 (0)