From f4f56db493fc090e390ad95378df560200332225 Mon Sep 17 00:00:00 2001 From: Horacio Daniel Ros Date: Sat, 31 Oct 2026 11:14:30 -0300 Subject: [PATCH] agrego practicas --- c/Guia de ejercicios.docx | Bin 0 -> 10924 bytes c/arena-lib/arena.c | 143 +++++++++++++++ c/arena-lib/arena.h | 29 +++ c/arena/main.c | 90 ++++++++++ c/arena/programa | Bin 0 -> 16336 bytes c/arena2/main.c | 82 +++++++++ c/arena2/programa | Bin 0 -> 16504 bytes c/arena3/main.c | 106 +++++++++++ c/arena3/programa | Bin 0 -> 16416 bytes c/arena4/main.c | 107 +++++++++++ c/arena4/programa | Bin 0 -> 16552 bytes c/arena5/main.c | 120 +++++++++++++ c/arena5/programa | Bin 0 -> 16496 bytes c/arena6/main.c | 178 ++++++++++++++++++ c/arena6/programa | Bin 0 -> 16544 bytes c/arena7/main.c | 86 +++++++++ c/arena7/programa | Bin 0 -> 17064 bytes c/arena8/main.c | 102 +++++++++++ c/arena8/programa | Bin 0 -> 16832 bytes c/args/main.c | 73 ++++++++ c/args/programa | Bin 0 -> 16576 bytes c/args/util | Bin 0 -> 20256 bytes c/aritmeticaptr/main.c | 60 +++++++ c/aritmeticaptr/programa | Bin 0 -> 16112 bytes c/constptr/main.c | 25 +++ c/pipes1/err.txt | 4 + c/pipes1/errores.txt | 1 + c/pipes1/listado.txt | 7 + c/pipes1/main.c | 9 + c/pipes1/programa | Bin 0 -> 16056 bytes c/pipes1/salida.txt | 3 + c/pipes1/test.txt | 2 + c/pipes2/main.c | 16 ++ c/pipes2/programa | Bin 0 -> 16064 bytes c/pipes3/.vscode/tasks.json | 28 +++ c/pipes3/a.out | Bin 0 -> 48048 bytes c/pipes3/entrada.txt | 2 + c/pipes3/main | Bin 0 -> 19160 bytes c/pipes3/main.c | 42 +++++ c/pipes3/programa | Bin 0 -> 48048 bytes c/struct1/main.c | 69 +++++++ c/struct1/programa | Bin 0 -> 16360 bytes c/struct2/main.c | 92 ++++++++++ c/struct2/programa | Bin 0 -> 16104 bytes c/struct3/main.c | 347 ++++++++++++++++++++++++++++++++++++ c/struct3/programa | Bin 0 -> 17104 bytes c/swap/main.c | 28 +++ c/swap/programa | Bin 0 -> 16088 bytes c/swap2/main.c | 48 +++++ c/swap2/programa | Bin 0 -> 16064 bytes 50 files changed, 1899 insertions(+) create mode 100644 c/Guia de ejercicios.docx create mode 100644 c/arena-lib/arena.c create mode 100644 c/arena-lib/arena.h create mode 100644 c/arena/main.c create mode 100755 c/arena/programa create mode 100644 c/arena2/main.c create mode 100755 c/arena2/programa create mode 100644 c/arena3/main.c create mode 100755 c/arena3/programa create mode 100644 c/arena4/main.c create mode 100755 c/arena4/programa create mode 100644 c/arena5/main.c create mode 100755 c/arena5/programa create mode 100644 c/arena6/main.c create mode 100755 c/arena6/programa create mode 100644 c/arena7/main.c create mode 100755 c/arena7/programa create mode 100644 c/arena8/main.c create mode 100755 c/arena8/programa create mode 100644 c/args/main.c create mode 100755 c/args/programa create mode 100755 c/args/util create mode 100644 c/aritmeticaptr/main.c create mode 100755 c/aritmeticaptr/programa create mode 100644 c/constptr/main.c create mode 100644 c/pipes1/err.txt create mode 100644 c/pipes1/errores.txt create mode 100644 c/pipes1/listado.txt create mode 100644 c/pipes1/main.c create mode 100755 c/pipes1/programa create mode 100644 c/pipes1/salida.txt create mode 100644 c/pipes1/test.txt create mode 100644 c/pipes2/main.c create mode 100755 c/pipes2/programa create mode 100644 c/pipes3/.vscode/tasks.json create mode 100755 c/pipes3/a.out create mode 100644 c/pipes3/entrada.txt create mode 100755 c/pipes3/main create mode 100644 c/pipes3/main.c create mode 100755 c/pipes3/programa create mode 100644 c/struct1/main.c create mode 100755 c/struct1/programa create mode 100644 c/struct2/main.c create mode 100755 c/struct2/programa create mode 100644 c/struct3/main.c create mode 100755 c/struct3/programa create mode 100644 c/swap/main.c create mode 100755 c/swap/programa create mode 100644 c/swap2/main.c create mode 100755 c/swap2/programa diff --git a/c/Guia de ejercicios.docx b/c/Guia de ejercicios.docx new file mode 100644 index 0000000000000000000000000000000000000000..350958fd4b1ab1f6c0a2fe6531a5d463da41c5e9 GIT binary patch literal 10924 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 YC8Z<_4fEFwg!iY<`(^$}^Vhro1AC$e&Hw-a literal 0 HcmV?d00001 diff --git a/c/arena-lib/arena.c b/c/arena-lib/arena.c new file mode 100644 index 0000000..50442f2 --- /dev/null +++ b/c/arena-lib/arena.c @@ -0,0 +1,143 @@ +#include "arena.h" +#include + + +char* arena_strdup(Arena* ref_arena, const char* s){ + char* str = (char*) arena_alloc(ref_arena, strlen(s) + 1); + if(str == NULL){ + return NULL; + } + strcpy(str, s); + return str; +} + +void* arena_chunk_alloc(Arena* ref_arena, Chunk* chunk, size_t s){ + size_t aligned = (chunk->offset + (ARENA_MEMORY_ALIGN - 1)) & ~(ARENA_MEMORY_ALIGN -1); + if ((aligned + s <= chunk->size)){ + chunk->offset = aligned; + void* start = (void *)(chunk->buffer + chunk->offset); + chunk->offset = aligned + s; + return start; + } + return NULL; +} + +Chunk* arena_chunk_create(size_t s){ + printf("Creating a new chunk of %zu bytes\n", s); + Chunk* chunk1 = (Chunk*)malloc(sizeof(Chunk)); + + if(chunk1 == NULL){ + return NULL; + } + + chunk1->size = s; + chunk1->offset = 0; + chunk1->next = NULL; + + chunk1->buffer = (unsigned char *)malloc(s); + + if(chunk1->buffer == NULL){ + perror("Error creando chunk...\n"); + free(chunk1); + chunk1 = NULL; + return NULL; + } + + printf("Chunk creado correctamente\n"); + + return chunk1; + +} + +void arena_chunk_free(Chunk* chunk){ + printf("Liberando %zu bytes de memoria\n", chunk->size); + if(chunk->buffer != NULL){ + free(chunk->buffer); + chunk->buffer = NULL; + } + free(chunk); +} + +void* arena_alloc(Arena* ref_arena, size_t s){ + if(ref_arena == NULL){ + return NULL; + } + + if(ref_arena->current == NULL){ + return NULL; + } + + Chunk* current_chunk = ref_arena->current; + + void* ptr = arena_chunk_alloc(ref_arena, current_chunk, s); + + if(ptr == NULL){ + + size_t new_size = current_chunk->size * 2; + + if(new_size < s){ + new_size = s; + } + + Chunk *new_chunk = arena_chunk_create(new_size); + if(new_chunk == NULL){ + return NULL; + } + + current_chunk->next = new_chunk; + new_chunk->next = NULL; + ref_arena->current = new_chunk; + + return arena_alloc(ref_arena, s); + } + + return ptr; + + +} + +Arena arena_create(size_t s){ + Arena new_arena = { + .current = NULL, + .first = NULL + }; + + Chunk* chunk1 = arena_chunk_create(s); + + if(chunk1 == NULL){ + perror("Error creando arena\n"); + exit(1); + } + + new_arena.current = chunk1; + new_arena.first = chunk1; + + printf("Arena creada correctamente\n"); + + return new_arena; + +} + +void arena_free(Arena* ref_arena){ + Chunk* item = ref_arena->first; + while (item != NULL) { + Chunk *next = item->next; + arena_chunk_free(item); + item = next; + } + + ref_arena->first = NULL; + ref_arena->current = NULL; + + printf("Arena liberada\n"); +} + +void arena_print(Arena* ref_arena){ + printf("ARENA INFO\n"); + printf("==========\n"); + + printf("first: %p\n", ref_arena->first); + printf("next: %p\n", ref_arena->current); + + printf("==========\n"); +} diff --git a/c/arena-lib/arena.h b/c/arena-lib/arena.h new file mode 100644 index 0000000..7f28977 --- /dev/null +++ b/c/arena-lib/arena.h @@ -0,0 +1,29 @@ +#include +#include +#include +#include + +#define ARENA_MEMORY_ALIGN 8 + +typedef struct Chunk{ + size_t size; + size_t offset; + unsigned char *buffer; + struct Chunk *next; +}Chunk; + +typedef struct{ + Chunk *current; + Chunk *first; +}Arena; + +Arena arena_create(size_t); +void* arena_alloc(Arena*, size_t); +void arena_free(Arena*); +void arena_print(Arena*); + +Chunk* arena_chunk_create(size_t); +void arena_chunk_free(Chunk*); +void* arena_chunk_alloc(Arena*, Chunk*, size_t); + +char* arena_strdup(Arena*, const char*); diff --git a/c/arena/main.c b/c/arena/main.c new file mode 100644 index 0000000..b03fe0a --- /dev/null +++ b/c/arena/main.c @@ -0,0 +1,90 @@ +#include +#include +#include + +typedef struct{ + unsigned char *buffer; + size_t size; + size_t offset; +}Arena; + +Arena arena_create(size_t); +void* arena_alloc(Arena *, size_t); +void arena_destroy(Arena *); + +int main(void){ + Arena arena = arena_create(13); + int *ptrInt1 = (int*)arena_alloc(&arena, sizeof(int)); + int *ptrInt2 = (int*)arena_alloc(&arena, sizeof(int)); + float *ptrFloat1 = (float*)arena_alloc(&arena, sizeof(float)); + char *ptrChar1 = (char*)arena_alloc(&arena, sizeof(char)); + + int need = sizeof(int)*2 + sizeof(float) + sizeof(char); + + printf("sizeof int: %d\n", (int)sizeof(int)); + printf("sizeof float: %d\n", (int)sizeof(float)); + printf("sizeof char: %d\n", (int)sizeof(char)); + + printf("Necesitamos: %d\n", need); + + if(ptrInt1 != NULL){ + *ptrInt1 = 18; + printf("Primer entero: %d\n", *ptrInt1); + } + if(ptrInt2 != NULL){ + *ptrInt2 = 27; + printf("Segundo entero: %d\n", *ptrInt2); + } + if(ptrFloat1 != NULL){ + *ptrFloat1 = 3.1415f; + printf("Primer flotante: %f\n", *ptrFloat1); + } + if(ptrChar1 != NULL){ + *ptrChar1 = 'L'; + printf("Primer char: %c\n", *ptrChar1); + } + + arena_destroy(&arena); + + return 0; +} + +Arena arena_create( size_t bytes){ + Arena new_arena = { + .buffer = NULL, + .size = bytes, + .offset = 0 + }; + + new_arena.buffer = (unsigned char *)malloc(bytes); + + if(new_arena.buffer == NULL){ + perror("Error asignando memoria"); + exit(1); + } + + return new_arena; + +} +void* arena_alloc(Arena *ref_arena, size_t bytes){ + + if(ref_arena->buffer == NULL){ + return NULL; + } + + if(ref_arena->offset + bytes > ref_arena->size){ + perror("Memoria llena\n"); + return NULL; + } + void* ptr_ref = ref_arena->buffer + ref_arena->offset; + ref_arena->offset += bytes; + return ptr_ref; +} + +void arena_destroy(Arena *ref_arena){ + if(ref_arena->buffer != NULL){ + free(ref_arena->buffer); + ref_arena->buffer = NULL; + } +} + diff --git a/c/arena/programa b/c/arena/programa new file mode 100755 index 0000000000000000000000000000000000000000..080b0a1cd978de4d381963ed48e1dd353dd96c81 GIT binary patch literal 16336 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 +#include +#include +#include + +#define FPS 10 + +typedef struct{ + unsigned char *buffer; + size_t size; + size_t offset; +}Arena; + +Arena arena_create(size_t); +void* arena_alloc(Arena *, size_t); +void arena_reset(Arena *); +void arena_destroy(Arena *); + +int main(void){ + srand(time(NULL)); + Arena arena = arena_create(100); + + for(int i=0; i < FPS; i++){ + + int* ptrLeft = arena_alloc(&arena, sizeof(int)); + + if(ptrLeft != NULL){ + *ptrLeft = rand()%FPS; + printf("El datos del frame es: %d\n", *ptrLeft); + } + + arena_reset(&arena); + } + + arena_destroy(&arena); + + return 0; +} + +Arena arena_create( size_t bytes){ + Arena new_arena = { + .buffer = NULL, + .size = bytes, + .offset = 0 + }; + + new_arena.buffer = (unsigned char *)malloc(bytes); + + if(new_arena.buffer == NULL){ + perror("Error asignando memoria"); + exit(1); + } + + return new_arena; + +} +void* arena_alloc(Arena *ref_arena, size_t bytes){ + + if(ref_arena->buffer == NULL){ + return NULL; + } + + if(ref_arena->offset + bytes > ref_arena->size){ + perror("Memoria llena\n"); + return NULL; + } + void* ptr_ref = ref_arena->buffer + ref_arena->offset; + ref_arena->offset += bytes; + return ptr_ref; +} + +void arena_reset(Arena *ref_arena){ + ref_arena->offset = 0; +} + +void arena_destroy(Arena *ref_arena){ + if(ref_arena->buffer != NULL){ + free(ref_arena->buffer); + ref_arena->buffer = NULL; + } +} + diff --git a/c/arena2/programa b/c/arena2/programa new file mode 100755 index 0000000000000000000000000000000000000000..0d74a540b74498c567afb9ed947b884df8846d78 GIT binary patch literal 16504 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 +#include +#include +#include + +#define FPS 10 + +#define ARENA_ALIGN 8 + +#define ALLOC_TYPE(REF, TYPE) (TYPE*)arena_alloc(&REF, sizeof(TYPE)) + +typedef struct{ + unsigned char *buffer; + size_t size; + size_t offset; +}Arena; + +Arena arena_create(size_t); +void* arena_alloc(Arena *, size_t); +void arena_reset(Arena *); +void arena_destroy(Arena *); +bool arena_is_aligned(size_t); + +int main(void){ + Arena arena = arena_create(32); + + int *test = ALLOC_TYPE(arena, int); + + *test = 5; + + arena_alloc(&arena, 3); + + arena_alloc(&arena, 1); + arena_alloc(&arena, 5); + arena_alloc(&arena, 9); + arena_alloc(&arena, 8); + arena_alloc(&arena, 1); + + arena_destroy(&arena); + + return 0; +} + +bool arena_is_aligned(size_t pos){ + size_t mask = 7; + return (pos & mask) == 0; +} + +Arena arena_create( size_t bytes){ + Arena new_arena = { + .buffer = NULL, + .size = bytes, + .offset = 0 + }; + + new_arena.buffer = (unsigned char *)malloc(bytes); + + if(new_arena.buffer == NULL){ + perror("Error asignando memoria"); + exit(1); + } + + return new_arena; + +} +void* arena_alloc(Arena *ref_arena, size_t bytes){ + + if(ref_arena->buffer == NULL){ + return NULL; + } + + size_t aligned = ((ref_arena->offset + (size_t)((ARENA_ALIGN - 1))) & ~(ARENA_ALIGN - 1)); + + if(aligned + bytes > ref_arena->size){ + printf("arena_alloc(%d): NULL \n", (int) bytes); + return NULL; + } + void* ptr_ref = ref_arena->buffer + aligned; + + printf("arena_alloc(%d) ", (int) bytes); + + if(arena_is_aligned((size_t)ptr_ref)){ + printf("aligned: true "); + }else{ + printf("aligned: false "); + } + + printf(" base + %d", (int)aligned); + printf(" offset: %d -> %d \n", (int)ref_arena->offset, (int)aligned); + + ref_arena->offset = aligned + bytes; + + return ptr_ref; +} + +void arena_reset(Arena *ref_arena){ + ref_arena->offset = 0; +} + +void arena_destroy(Arena *ref_arena){ + if(ref_arena->buffer != NULL){ + free(ref_arena->buffer); + ref_arena->buffer = NULL; + } +} + diff --git a/c/arena3/programa b/c/arena3/programa new file mode 100755 index 0000000000000000000000000000000000000000..e104368dcf7112751b5acc2eb93aa7770b438993 GIT binary patch literal 16416 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 +#include +#include +#include +#include + +#define ARENA_ALIGN 8 + +typedef struct{ + unsigned char *buffer; + size_t size; + size_t offset; +}Arena; + +Arena arena_create(size_t); +void* arena_alloc(Arena *, size_t); +void arena_reset(Arena *); +void arena_destroy(Arena *); +bool arena_is_aligned(size_t); +char* arena_strdup(Arena*, const char *); + +int main(void){ + Arena arena = arena_create(16); + + char* s1 = arena_strdup(&arena, "arena"); + char* s2 = arena_strdup(&arena, "hola"); + char* s3 = arena_strdup(&arena, "x"); + + arena_destroy(&arena); + + return 0; +} + + +char* arena_strdup(Arena* ref_arena, const char *src){ + char* ref_str = (char*) arena_alloc(ref_arena, strlen(src) + 1); + if(ref_str == NULL){ + perror("No se ha podido reservar memoria para la cadena."); + return NULL; + } + strcpy(ref_str, src); + return ref_str; +} + +bool arena_is_aligned(size_t pos){ + size_t mask = 7; + return (pos & mask) == 0; +} + +Arena arena_create( size_t bytes){ + Arena new_arena = { + .buffer = NULL, + .size = bytes, + .offset = 0 + }; + + new_arena.buffer = (unsigned char *)malloc(bytes); + + if(new_arena.buffer == NULL){ + perror("Error asignando memoria"); + exit(1); + } + + return new_arena; + +} +void* arena_alloc(Arena *ref_arena, size_t bytes){ + + if(ref_arena->buffer == NULL){ + return NULL; + } + + size_t aligned = ((ref_arena->offset + (size_t)((ARENA_ALIGN - 1))) & ~(ARENA_ALIGN - 1)); + + if(aligned + bytes > ref_arena->size){ + printf("arena_alloc(%d): NULL \n", (int) bytes); + return NULL; + } + void* ptr_ref = ref_arena->buffer + aligned; + + printf("arena_alloc(%d) ", (int) bytes); + + if(arena_is_aligned((size_t)ptr_ref)){ + printf("aligned: true "); + }else{ + printf("aligned: false "); + } + + printf(" base + %d", (int)aligned); + printf(" offset: %d -> %d \n", (int)ref_arena->offset, (int)aligned); + + ref_arena->offset = aligned + bytes; + + return ptr_ref; +} + +void arena_reset(Arena *ref_arena){ + ref_arena->offset = 0; +} + +void arena_destroy(Arena *ref_arena){ + if(ref_arena->buffer != NULL){ + free(ref_arena->buffer); + ref_arena->buffer = NULL; + } +} + diff --git a/c/arena4/programa b/c/arena4/programa new file mode 100755 index 0000000000000000000000000000000000000000..f8581816b59e9c3735126fad38c8584e104ea5ee GIT binary patch literal 16552 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 dsn!dIV?O8HE-TXXznuNa&nb<|dY%Tx* literal 0 HcmV?d00001 diff --git a/c/arena5/main.c b/c/arena5/main.c new file mode 100644 index 0000000..f5a84ba --- /dev/null +++ b/c/arena5/main.c @@ -0,0 +1,120 @@ +#include +#include +#include +#include +#include + +#define ARENA_ALIGN 8 + +typedef struct{ + unsigned char *buffer; + size_t size; + size_t offset; +}Arena; + +Arena arena_create(size_t); +void* arena_alloc(Arena *, size_t); +void arena_reset(Arena *); +void arena_destroy(Arena *); +bool arena_is_aligned(size_t); +size_t arena_checkpoint(Arena*); +void arena_restore(Arena*, size_t); + +int main(void){ + Arena arena = arena_create(32); + + size_t cp0 = arena_checkpoint(&arena); + int* x = (int*)arena_alloc(&arena, 8); + +*x = 21; + + arena_alloc(&arena, 8); + size_t cp1 = arena_checkpoint(&arena); + int* tmp = (int*)arena_alloc(&arena, 8); + + arena_restore(&arena, cp1); + + printf("x:%d\n", *x); + + arena_alloc(&arena, 16); + + arena_restore(&arena, cp0); + + arena_alloc(&arena, 32); + + arena_destroy(&arena); + + return 0; +} + +void arena_restore(Arena* ref_arena, size_t chk){ + ref_arena->offset = chk; +} + +size_t arena_checkpoint(Arena* ref_arena){ + return ref_arena->offset; +} + +bool arena_is_aligned(size_t pos){ + size_t mask = 7; + return (pos & mask) == 0; +} + +Arena arena_create( size_t bytes){ + Arena new_arena = { + .buffer = NULL, + .size = bytes, + .offset = 0 + }; + + new_arena.buffer = (unsigned char *)malloc(bytes); + + if(new_arena.buffer == NULL){ + perror("Error asignando memoria"); + exit(1); + } + + return new_arena; + +} +void* arena_alloc(Arena *ref_arena, size_t bytes){ + + if(ref_arena->buffer == NULL){ + return NULL; + } + + size_t aligned = ((ref_arena->offset + (size_t)((ARENA_ALIGN - 1))) & ~(ARENA_ALIGN - 1)); + + if(aligned + bytes > ref_arena->size){ + printf("arena_alloc(%d): NULL \n", (int) bytes); + return NULL; + } + void* ptr_ref = ref_arena->buffer + aligned; + + printf("arena_alloc(%d) ", (int) bytes); + + if(arena_is_aligned((size_t)ptr_ref)){ + printf("aligned: true "); + }else{ + printf("aligned: false "); + } + + printf(" base + %d", (int)aligned); + printf(" offset: %d -> %d \n", (int)ref_arena->offset, (int)aligned); + + ref_arena->offset = aligned + bytes; + + return ptr_ref; +} + +void arena_reset(Arena *ref_arena){ + ref_arena->offset = 0; +} + +void arena_destroy(Arena *ref_arena){ + if(ref_arena->buffer != NULL){ + free(ref_arena->buffer); + ref_arena->buffer = NULL; + } +} + diff --git a/c/arena5/programa b/c/arena5/programa new file mode 100755 index 0000000000000000000000000000000000000000..88b4f118b3c4b6a99dd61f258792ec7fd839c1fe GIT binary patch literal 16496 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 literal 0 HcmV?d00001 diff --git a/c/arena6/main.c b/c/arena6/main.c new file mode 100644 index 0000000..b998d84 --- /dev/null +++ b/c/arena6/main.c @@ -0,0 +1,178 @@ +#include +#include +#include +#include + +#define ARENA_MEMORY_ALIGN 8 + +typedef struct Chunk{ + size_t size; + size_t offset; + unsigned char *buffer; + struct Chunk *next; +}Chunk; + +typedef struct{ + Chunk *current; + Chunk *first; +}Arena; + +Arena arena_create(size_t); +void* arena_alloc(Arena*, size_t); +void arena_free(Arena*); +void arena_print(Arena*); + +Chunk* arena_chunk_create(size_t); +void arena_chunk_free(Chunk*); +void* arena_chunk_alloc(Arena*, Chunk*, size_t); + +int main(void){ + + Arena arena = arena_create(32); + + arena_print(&arena); + + arena_alloc(&arena, 100); + + arena_print(&arena); + + arena_alloc(&arena, 40); + + arena_print(&arena); + + arena_free(&arena); + + arena_print(&arena); + return 0; +} + +void* arena_chunk_alloc(Arena* ref_arena, Chunk* chunk, size_t s){ + size_t aligned = (chunk->offset + (ARENA_MEMORY_ALIGN - 1)) & ~(ARENA_MEMORY_ALIGN -1); + if ((aligned + s <= chunk->size)){ + chunk->offset = aligned; + void* start = (void *)(chunk->buffer + chunk->offset); + chunk->offset = aligned + s; + return start; + } + return NULL; +} + +Chunk* arena_chunk_create(size_t s){ + printf("Creating a new chunk of %zu bytes\n", s); + Chunk* chunk1 = (Chunk*)malloc(sizeof(Chunk)); + + if(chunk1 == NULL){ + return NULL; + } + + chunk1->size = s; + chunk1->offset = 0; + chunk1->next = NULL; + + chunk1->buffer = (unsigned char *)malloc(s); + + if(chunk1->buffer == NULL){ + perror("Error creando chunk...\n"); + free(chunk1); + chunk1 = NULL; + return NULL; + } + + printf("Chunk creado correctamente\n"); + + return chunk1; + +} + +void arena_chunk_free(Chunk* chunk){ + printf("Liberando %zu bytes de memoria\n", chunk->size); + if(chunk->buffer != NULL){ + free(chunk->buffer); + chunk->buffer = NULL; + } + free(chunk); +} + +void* arena_alloc(Arena* ref_arena, size_t s){ + if(ref_arena == NULL){ + return NULL; + } + + if(ref_arena->current == NULL){ + return NULL; + } + + Chunk* current_chunk = ref_arena->current; + + void* ptr = arena_chunk_alloc(ref_arena, current_chunk, s); + + if(ptr == NULL){ + + size_t new_size = current_chunk->size * 2; + + if(new_size < s){ + new_size = s; + } + + Chunk *new_chunk = arena_chunk_create(new_size); + if(new_chunk == NULL){ + return NULL; + } + + current_chunk->next = new_chunk; + new_chunk->next = NULL; + ref_arena->current = new_chunk; + + return arena_alloc(ref_arena, s); + } + + return ptr; + + +} + +Arena arena_create(size_t s){ + Arena new_arena = { + .current = NULL, + .first = NULL + }; + + Chunk* chunk1 = arena_chunk_create(s); + + if(chunk1 == NULL){ + perror("Error creando arena\n"); + exit(1); + } + + new_arena.current = chunk1; + new_arena.first = chunk1; + + printf("Arena creada correctamente\n"); + + return new_arena; + +} + +void arena_free(Arena* ref_arena){ + Chunk* item = ref_arena->first; + while (item != NULL) { + Chunk *next = item->next; + arena_chunk_free(item); + item = next; + } + + ref_arena->first = NULL; + ref_arena->current = NULL; + + printf("Arena liberada\n"); +} + +void arena_print(Arena* ref_arena){ + printf("ARENA INFO\n"); + printf("==========\n"); + + printf("first: %p\n", ref_arena->first); + printf("next: %p\n", ref_arena->current); + + printf("==========\n"); +} diff --git a/c/arena6/programa b/c/arena6/programa new file mode 100755 index 0000000000000000000000000000000000000000..774be348d94d4287cf913b543f28cc6913178889 GIT binary patch literal 16544 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 +#include "../arena-lib/arena.h" +#include + +typedef struct Persona{ + char* nombre; + int edad; + struct Persona* next; +}Persona; + +void print_persona(Persona*); + + +int main(void){ + + printf("Alinacion struct Persona: %d\n", (int)_Alignof(Persona)); + printf("sizeof struct Persona: %d\n", (int)sizeof(Persona)); + + Arena arena = arena_create(32); + + char continuar = 'S'; + + Persona* first = NULL; + Persona* last = NULL; + + do{ + char input_name[50]; + printf("Nombre:"); + if (fgets(input_name, sizeof(input_name), stdin) != NULL) { + input_name[strcspn(input_name, "\n")] = '\0'; + } + + int input_edad = 0; + + printf("Edad:"); + scanf("%d", &input_edad); + printf("\n"); + + int c; + while ((c = getchar()) != '\n' && c != EOF); + + Persona* p = (Persona*)arena_alloc(&arena, sizeof(Persona)); + + if(p == NULL){ + perror("Ha ocurrido un error\n"); + exit(1); + } + + p->nombre = arena_strdup(&arena, input_name); + p->edad = input_edad; + p->next = NULL; + + if(first == NULL){ + first = p; + } + + if(last != NULL){ + last->next = p; + } + + last = p; + + printf("Cargar mas personas? (S) Continuar, (N): Terminar :"); + scanf(" %c", &continuar); + + while ((c = getchar()) != '\n' && c != EOF); + + }while((continuar == 'S') || (continuar == 's')); + + printf("Listado de personas cargadas:\n"); + printf("=============================\n"); + + Persona* current = first; + while(current != NULL){ + print_persona(current); + current = current->next; + } + + arena_free(&arena); + + return 0; +} + +void print_persona(Persona* ref_persona) { + printf("%s: tiene %d years\n", ref_persona->nombre, ref_persona->edad); +} diff --git a/c/arena7/programa b/c/arena7/programa new file mode 100755 index 0000000000000000000000000000000000000000..beace48eb23c77cd4fa635fc4a73b51b3f9f2737 GIT binary patch literal 17064 zcmeHOeQ;dWb-ycFw(tiMUR*B)HUyj|<`&uTn@v3-YbH z0um8BMFW1?3WNSfbUuT09T}l8C0!~+>3={Af;0jdm5BTmBG}$JZ5O15)@Mp>P&xXB z7yqBM*P-oZKC1i#X;Q(0DYth_+s)mm6oPa_+cD+-{W9!m9R9n7r_~YNUZrtw(c{fj z52GA|m1vBHZ~x&=vFmHii|%c?Y2QOrFFpB&b@YRsZ#&NBWTI=w_RY!oreq?O9oRIm zbH}C~+ryc3c&i|{WKaH7+=duJoeJSSoi>LkvEa`Z09OY=@OM18FIOS=fc5kbI-(3O!7vKi|gCzlAA^)o?;5#bdKLu{!KUh8u z;D#Uw{!08`C02`}h!XOA7TrCLmk}Ayjr9+L#1kpep9RwIxNh1NmX-1B*l{b?d)(@_ z6G_qSI*xD#5*|c}Oggr8o0W;#scy20_1Z4EN;)Y4x6H;e{VCCBCzI(Ij4)Ya8N5U6KX_nIyR|jEZKq$|?$@>zt6Rgj2B z(lP9ph^o=?PRAIR`iQC#PTA$s7*RFC<@H$$noID~^RQ8ZlMR;*5mh6Mb4N%^gnoq} zT;Ccr>LYTif;nftT%;6X6pO@_wZg~lCVg1Ya zZCD#Yjrd-Y&CV21);~u)UFv72B>xTK=@LIXA^EQoPq!wsXC?oq#M3Rw?6~BgB%Ut) zv!^8g1o3pqpB<9?=ZL4v_iVr9KSMlS;%D!b{HKYhOZ#kxm+)Cb@?FH!rF*s!Jmq7{n+I~Q{f3$Qp*j5eT*tBKmWeIjHpg~1BgjJ2Xjq8% zy2A}?Pr?KV8{2&=9GGKuTZ!B{?=>NnDJW4YuPDqktQ{h~=QV}?6;l6}8X_Ano4Gmj z*|%;tpPjEYL+8!cE_*BCV7GQqUzq7`Si84qPw@@yeg$HY-PUOi?_Nz+GxvtK!W`ZG zMKFb?di>^N=*;=LFQ6K_=lNp1h$AApi#++8?SXD5d|)CNX6{7Z%w=cH(ddkso6P^x zj;4d{vCq8i_tc7(Rp+D#JtEZIY<4wc&$0wNk;Qp>D_;a9oTO_FFmu@T<5g( zJQ}GthbNYp!!t05&cPV}(P=aEoDw6IQ|>NRhbY&98H#{LI~o;*d1y)o5wKL6^B3!6 zSof&bxnIsyqvBZ zFuN}<0x%co-(+--GR~P-CX@M>RJeJBn-|$t7>QrO>4Q4*%mN9gSQ|-IkLFyv*3&%NB}LE^kg!+;q}; z6DK+{`rY?ShYur-2{KmqeJyePGl^KUdwrVALVJZ^Ng9R8SNawfSpn2 zwln^*JAC4l$kK5Go#-jJKP|lFU{5PEdGaCAX^g{h)uhVTiU6l=FZQ z>&>Q)8|iLi{exMfYtVBtOGT7k6d5rnrs8R(5e|o!igu|>IKgSxbz+{~=cGIbX+4gzHQXHhrqY~k*5xmB2(RL(yxXn0lc;B63w_ike z!p(TC#`^xHBIOL|ni}IaygIdGiFC@q`>SlsGddhMlTO*tjxQA%yqQ9$7ZM##_jS2W zt3b$cJKieR$AxJd=~&iv6Xlf9w+jWj=iNA0D7*+d44MZGy;CUE<8Jg7&<&uQ z{}uOdpbhU93iO2MBX=q3f0}sXql7;q)!X zIAXYo6!$KX>(6zlZpZ)WHwy*18oRP_-<8dGG%S0den{ND`nH?5t-FEL$@UZYzZ
^V42+W<)483_aINu(>3mY zZM=pQ)&P14@)?W?<z|cHqeg^d> z{J*Z{a{Rzk75k zLN`w+{LRwq&5Eb*6RGg`Y1b*%|E6lS=J`7{y6>cdTX0!^e7TUO%8T^I7lrQcsN{8p z?m4N{PfZL- zdUXZ-rV4mFaHGtFVm^rzfgx6j{z$pdl75zp3$%bmk!x$v;}Vxp+0Vlj@ZSc$(0A2; zr2WUW|NFGJr+_yio}oyYd-3O_U$a8+`Ie<$mwuQl(w8gXKdOMgFY)E#3Y~2EtOV|s zAU{`QzQr^ypOFAxCGlc=T-&7e-_|G8tQNFZ&_7rK@78{Ppxc$tUf^pGIOQieUXN7p z^8|2%gDatb0{p6)Rf5kaEP9%7`Wjvv@pFN1N&m}5gYMUiHh4|qY+aA}eJWDK zsP-xCr%|6D_?gJ8)*lM!|5)qq|A_J73xPYn1C<&fkaCjT|KTI=(^ji=s-JQT$8M*sio%LBf{E$@XkGL2dz8z?K>JhW*uwWb1-VjeG(Dg zyFhyr^!|u4>_6>>@TJ(;@Uu2E$gnNBSAsTNVDE-+soTnw0diwU8KOMM-5iz^w>?|P zJnHQmWvanFAii+B-mT#S)V6YrpyJtn&B(U~mf8S9(PBTy0w(mP0PhCmhLkdK`9>38 zgbg98E#+RDV-le=YMTddLh()H9+AL45G$TZTfKM{L3>0F+zCtUfw8g~C$8PAxYhoZ za!;5lm=Il=jBZZuXDN+IrdRExDYKLVXXyv|ayLzx*s_itYUi0pTUr*}r&7LgrrZI| zb0NZ+!9LIK0`*))d%2cMdrr6~l?``g6WBPGh>I}x-8gQ)kZ7-+=@sGlUcg@(4qN6Bs61Fj*blGY zO(RX-poZG^9N0wX66snU$jUX>5rN&8h#|Z*8pTgoMxt89NQp4cC-f4^KT-YfDzpxw zTYj9bWvR5kQj2l#RbKENrog4yw|@%fQz}e(9i>pE%XOl(KMb!~(%e3;ub8gW%G@rm zYcwn(s1%>Z7uR3B4x6XoP-vM(Rkr7KkO_=J=Jt6#$CTG^P?1HuV^(yaMr$Ru=k*cO zo3$p#&w5Pnft=P}%=7w-Dfy=oj9;Nb?h7T~Y|raIrs{r{?wM5y_WypsB-^9qyq@%_ z?l9?4&Vu$sz(|GHzy5VpUr%|R4Ha294(30JN~yh}?U>H7qNZBxH}goqp6^?j{v9uj z1NQ9pv4B0_zcS_L2&^BB|8v@&^Dhjosp*W)pGN)sG5-WAq{8;R?qHf^MNNb4p9$D^ z+@KVhe*V8`|Eo~Pt2KZA1@{pL+voAu;fQabQhNRvSf?aRBdn-t(Eb(RrS|8vJyRoK zAMF44AjjRXzekXt@9;k5V0+9n{Sj;%O6++(JG}`Y3hODZ$TR*f1T^>cY0qCz`up5< z{`q+k+wnZ6cdMkr_Pp=E{{_Ib r6ybjJ`JbMPaqP-c{YL1*gmN+< + +typedef enum { + BIN_OP_SUMA, + BIN_OP_RESTA, + BIN_OP_MULTIPLY, + BIN_OP_DIVISION +} BinaryOps; + +typedef enum { + NODE_NUMBER, + NODE_OPERATION +} NodeKind; + +typedef struct Node{ + union { + BinaryOps operation; + int number; + }value; + NodeKind type; + struct Node* left; + struct Node* right; +} Node; + +Node* create_number(Arena* arena_ref, int n){ + Node* node = (Node*)arena_alloc(arena_ref, sizeof(Node)); + if(node == NULL){ + return NULL; + } + node->type = NODE_NUMBER; + node->value.number = n; + node->left = NULL; + node->right = NULL; + return node; +} + +Node* create_operation(Arena* ref_arena, BinaryOps op, Node* l, Node* r){ + Node* node = (Node*)arena_alloc(ref_arena, sizeof(Node)); + if(node == NULL){ + return NULL; + } + node->type = NODE_OPERATION; + node->value.operation = op; + node->left = l; + node->right = r; + return node; +} + +int node_compute(Node* node){ + if(node->type == NODE_OPERATION){ + int r1 = node_compute(node->left); + int r2 = node_compute(node->right); + int result = 0; + switch (node->value.operation) { + case BIN_OP_SUMA: + result = r1 + r2; + break; + case BIN_OP_RESTA: + result = r1 - r2; + break; + case BIN_OP_MULTIPLY: + result = r1 * r2; + break; + case BIN_OP_DIVISION: + result = (r2 != 0) ? r1 / r2 : 0; + break; + default: + result = 0; + break; + } + return result; + } + + return node->value.number; +} + +int main(void){ + + Arena arena = arena_create(32); + + printf("Memory struct information\n"); + printf("=========================\n"); + printf("sizeof(Node):%zu\n", sizeof(Node)); + printf("align(Node): %zu\n", _Alignof(Node)); + + //Creamos el arbol para 3 + (4 - 1) + Node* t1 = create_number(&arena, 3); + Node* t21 = create_number(&arena, 4); + Node* t22 = create_number(&arena, 1); + Node* t2 = create_operation(&arena, BIN_OP_RESTA, t21, t22); + Node* root = create_operation(&arena, BIN_OP_SUMA, t1, t2); + + printf("Node compute\n"); + printf("============\n"); + + printf("result: %d\n", node_compute(root)); + + arena_free(&arena); + + return 0; +} diff --git a/c/arena8/programa b/c/arena8/programa new file mode 100755 index 0000000000000000000000000000000000000000..10b91c4ce559f98fdba9314ddafba0c2c08e666a GIT binary patch literal 16832 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 +#include +#include +#include +#include +#include + + +static struct option option_args[] = { + {"help", no_argument, 0, 'h' }, + {"verbose", no_argument, 0, 'v' }, + {"output", required_argument, 0, 'o' }, + {"max", required_argument, 0, 'm' }, + {0,0,0,0} +}; + +void print_usage(char* arg){ + fprintf(stdout, "Uso: %s\n", arg); + fprintf(stdout, "[--help]\n"); + fprintf(stdout, "[--verbose]\n"); + fprintf(stdout, "[--output ]\n"); + fprintf(stdout, "[--max ]\n"); + fprintf(stdout, "[posicionales...]\n"); +} + +int main(int argc, char* argv[]){ + + printf("argv[0]: %s\n", argv[0]); + + int opt; + int opt_index = 0; + + while((opt = getopt_long(argc, argv, "hvo:m:", option_args, &opt_index)) != -1){ + switch (opt){ + case 'h': + print_usage(argv[0]); + exit(0); + break; + case 'v': + fprintf(stdout, "Modo verbose: ON\n"); + break; + case 'o': + fprintf(stdout, "Output: %s\n", optarg); + break; + case 'm': + errno = 0; + char* errorptr = NULL; + long maximo = strtol(optarg, &errorptr, 10); + if( (errno == EINVAL) + || (errno == ERANGE) + || (*errorptr != 0) + || (maximo < INT_MIN) + || (maximo > INT_MAX) + ){ + fprintf(stderr, "--max debe ser un numero entero valido.\n"); + exit(1); + } + printf("Maximo:%ld\n", maximo); + break; + case '?': + print_usage(argv[0]); + exit(1); + break; + } + } + + fprintf(stdout, "Posicionales:\n"); + for(int i = optind; i < argc; i++){ + fprintf(stdout, "%s\n", argv[i]); + } + + return 0; +} diff --git a/c/args/programa b/c/args/programa new file mode 100755 index 0000000000000000000000000000000000000000..fe3fcb604bd391c7eb56353d1a50f5c6c83fbc66 GIT binary patch literal 16576 zcmeHOZ*WxA6~DVlG=PwRNeiOzpkTq4WfLF;Y+wUycyYoXAvm;_zHG9aWb6J(cV94A z(afL@JAs+lPCJg%59+iX$8pBi_CtqGH53%>w4FG9C~c{eaq5^1h_Osl^E-d;z31Kca^Jpt?+>@P`h7mZR3Wwql16GBB*cnMTo588Hi{aY zmx?9g8o-q}LQ1W3v%*m@uU2*hli$-yuk#y~9dm9Waq=riBdP-CLiL0Es>n&nI{(1$ zL}bqTLVbp#7aE@;0}yk!ALV9jjZ}-V=3*XH{q9tp{iqq_H?I7~m0y9Y`oh+B&Kb;%Ok2%-3{|!6(Y3kdn{5n-Yov%>! zG3WX^lwY-Kr_PTnKjz%O+u=vo;lCvwR{KCePdb`Lb& zgAuDIo{A*m_ryfc-I=%@6TLATo>n5A>J{WkBcVy`Y;W7P-D(W1FO(Vs8w%xh>xI?U zvCE3aGO^xx){bR5c5O$5SVyEQ5kp12$#hCJ!E#JX8VW%JxDw-z{%G9t*(v!T_W|eo zqAniC5Udm#g$>*gpG98xD)|=={{X|*FOEYd;^!sjeQ3UepI6UA#)AqsLyn$tmOC}P z(s1mCG<=rAAJg#p3Ln+*g^bgH2GKo7V}t1>7w%^ee9VPk>%z~w@YybW+=b6^;XE$s ze;VK8q~>u+INkG1JT3{J#~|^LBT!q^zYYmhyKo-kq^Nb_6pLwL$SF}A`TS7|!-ey; zA=N4uj)CBjmjN#WUIx4jcp30A@EK;{-I^u;G>=`XHixTDuNA_4aMbqa$IN4AtIx<* zy;U($9Wg+I|&f^W@P>=E=Fs&`mUmrjzFI zz}Rs3LR)S+cWz?xqkKLWzJi+bH4lCZT|?yWOWWr2n39^g)2HB~>i!VM!&Ub|oeNK0 z+%z1XG9NKd*1Z4&L`A24=yxq5?3WSd{#Zu%gPA+$bpMC&KNgLHO16~Ha40svvGT>#v%Yc^wF9Ti%ybSz*WWa}S zE`6~?zc?JrbfvQ~f$vfM_#~B#3<`XcI(%pF&}L(0cDC4+j;0M|wAt9R8%Sg@o=k5h z<>8*qVsAPd?~bSOi7J-eJX;V9@-42obp<&605JM?K7SBAIF-+bz*oPM&kunU(YH?` z-#z<;Z?M+4__}MWNASi;IIRJgfbY#@u;bcVVia>dj!xkH1k9^#owx9|nmKn@4~eZe z+V zm+=w{qKc_gEO(+@kE0!JAd>BaOh100$JLcws=cOSp&y^ZY5~rvKp6UxqpUPtB{Wng z{UAc$f&D{blrU;Kkx%%FWWOepEwz*E$)AWYIy~|+;AOzefR_O;16~Ha40svvGT>$4 ze=7sLPL9{b@q2^(VvDX8){4(z+-~^=8@9X_jqCqc-suli(iERRW&aK;f4ufdne&X-Oet?v`VW-M z^>TAQYtHM(^?IAsIA~S;4#j&EKdkseitGL?n;|Y0^Gc&wW~omVW|h$&R{Hr$&-qob zkV%HX>o9eFk_|tB@7%t9v#|_jzZysdN_cugIx8dx=dgWCuj?DSEL*n&Vd43}+A1WZ)Ozvdz_k$4Wef09>%V^@?H7qqh$B1vcHp%F zPtTTO{Gf`%>vH*bn7e>4@Xr`A|bW zXUoJn58QCIgNtuc9RDJr-}hGtrzIiEiThiD2X!s#4YqIuhd%}T1sI3C-{@wgu2%MX zKI?#!eNL_W?t(wjB8fX?_xYAGcr$QnzaGC0xZw_<%H6=1m%#4>zQB+FV%mKw_IGFO zhCmuC>LXoo%Z~I409{yfpV|*}X8FBkC#`N;fS-kFG;Q@J(p`~+6}8iutQ8p;6y51$ zeS)>49)^d$p&`VZ6Fy-Zg0nB8U`-nstXMQ+N7QzTVh!~lbro;0D448w?~^E? zGNeTzoy`tv4@Qw*?Y=0&^bHbLG@G{iBB>~Co@m>HV9|KW8py`5gldrUn9C z195C9ibq8NJ56Glej(AmNVZP|qDNAQ;BY(RXz&Rji(mPR1Pi)MED<3GRq9XJ6cMcm z*s(#JVtr~@_C?{#5*jK8s|XaD*PluE$1?U21+{EzTSNDf4DAeLCp4GQ zf=Dvnjpn6MDNX^|5~o&N3K78ll*DaP;$HqV5Y3NiZimN!q;mW2lp6mNiwUdR1UM`3Xwp8 zVzd7vYTnMA`_J|3{ik^<>9*mJ#0H9wD41+0XRPM@4FRK^sA^~akEs7A{Qd&ydi%et{0r3>%2IK< zzHZX}ABB?o&;Ff;W6gYpBNooO|C7+T{f`@tDf4>^o=$bpH~uACKb?fsqOOkE-7VM%R)x_L(`X zaAtqzwDsNX&%Y~7D1Woy=@i(H`E1QU6mslBL5GhztZ+68C8tmee~QKJFU&_99K8xt z@G=S|r%(c6-cnc{MmpDaq(ld`y_2y?P_-4 z%EEzK2{u7hutkz_94EFZGj6bxPN>^S9pc8qb_{M@4YmoEn_Qa4RC2SM8F6RJ1mc&1kye=j z@v~LTi{lcunB{}d*^%-Q0Wbk8}o^=Uc(M&sv&81o)ztogX>t(z9B~^A*9NCRXyAf%Z zrsNRGB~|gHn9%RIEYC?7lM#}lq)Uk?{dO)Q?$gxIQ99=$IqMsec1~(YeMMD$yRO>d z|4w~7rQNtJ&`EEU^(m_A+b!)b)(8bBJudAORqeYKc61*8t4VdM+hl#yo_9LINcED+ z)5y=kEZ}tdHgDgZ|Qr zwX$|)qc0ivHE_F9*iw1iZyh;pfr~INe&pYE*L-=w>h}g0G`#T9%s)T<(M&+orge}^ zrI4Hke-XHWpEFTBrz+>(Y4F>p!S_sqUjc65=S&L$OjU2yGOmsqu4iqB8gl%>QBQcU&i3IEDNkn3H2NXhmL9-(g z3q~V%Tdd=*M8vj$LMIkCqw!GCj>KcE)3Q+__*f^S5~&BSWSh6PZP;iw_*Se+XB*SG z2H#ET{E9|qw(Z_#qH3!%lC-VF?rj@Un6*3D9;NC!yW=tGr72XWR78Yayx-^HNPl#P z7gX?c)No}DL87kDr%yhJ%R^@mOKesoQbKpY$0eVd7r_(6&Auo3zu@{V_CxTL)O}o? z*Hh&Je_h_E6~0sA0l$zdT=54SxW^EB{SLfD;-?&VrNoCF_yUEmXFSopfclt97c+46 z=posq3|#q2`0E+?3<6{t$-oi7$t3$LJx=M~qmt_1gsXEwGS$BcmmwpVsq2Jrx__mU zU*rlvTxpOoPX?~8ArhBm;8d1MbNwPm{xd`MU@P8o!?|T>iCUEo@p1`1fzK*fLeZ#hE;!@z~3!dk>dlNVP zHQ;8&{$b+jkv!JV`L7U9kKM5z@Z|6EU$zZgzB4dzC2;hucXsY>T|T`0rND`% z@4$(P%C|8B|DeO?t)>|U8g!zms-B2GlgR3EyAn-(1xnP^!if=YbwBAnFDdlLP+{Q2 zO;?Cq_eo&joxu5Dtq+_ZcL%f=1D8LsXQ6;cWC5Oukq&Ql%cMQ|*WdI@*s|1$J%OW5 zcSDl}2CmvAfx)I%!Aw+k;W!#XV_wu>fTFhl`AL7_ho5y!@>JefCv^9q44kO4z`&7l zIM71g4el8aoG95>N)@~k7`X5>wPf@gpG-_ZV-abbXlmio^XF*L@*_G;qfZFAOUQjv zPJ=rk9}w~@@Dld(rMxmNj|lm5LS8QAAkw}~$WIG7jRFG$=g-k(Oq72e-h5Fz+fwWaG>(17+wYjUJMMpCYtx;zfVkDXnhl!Z0ryk zbo9tuz4je+^ga*~eBAB<`>!3@Oaew zeRl6~YF6M2N8W*9|KTFap}XAkhu6cGJ9(*1&*J3LIiT2i|0)u5} z(Nc^#=2l4)D`KC-z-oV8|z}JZqD|^laUaXj)GAu>GS!Zf%T}~ zJL>m~vbV*ELnx) zz9P0Q*ca)JuUQfe7qPD1_?qrDY-dL8Yl;}PhH3NNYcZAJ>#oawJuz_r`KLhxpnrx5 z)N#-+zB@5-29y%5%~I0tzKv;pW!n511)d>Hpa`dL6uMx$loVPD`0~bLWE=4t{uL&> zgqN0WDxJHby)qb7|Qz*T#~3*UP9u$PWYlDdc_h zRz=C(Nf%cj8>B1$;MU!2oUek>%M*h@B)s%s>)-<=a*U>zitk6BruE;Ia_&EPss?Ld zo;;N+%XiOpVcDh(V6hv;(29oCa>(e#4%JC7bZ8yh)z5|rqq!y}jcHlD%fXW_`APa@ zPl+)4U>T+&JmJemp49hlG=HI_RYL~QjO*(nMoGQM&JhO1&7i}NG0A(&QiUd0*HG|oRG<^LvmRj+jCf1RlB$DI|gl>K0nq_<1jA!)Cq z$0U7F(m#<@l^5`*}USqWTs>qd9RdLO1X-!gqb=i>U&40yjv;$Cv@}1jcbf$ zm}y>TEMMts@GUnQ>Kj(puUcNu==Ff;UZRscA-_*-Q+?1;^fmfMliE7YEYrqF(!`m1Eku%=IkQT8k|gUn z`^F=K|YP-12QSCKS+v6R8 z!f~yHB>PM512&}XARBYeS3w@q<`Z+E>JgAr+Fy}ckb8GVJ4OYx7dC^O)#^wRsyq#~ zr?sVI6XvcCYhNQt2WMW;j+3OTlzQz&ZIC40o^J!Y#B{pD<`qqOVJ9?P ze*nfsa1otW^0%0J1Hg9V3%8Q^e#+t94Y~&%D12P|FOlKe1#1_;BqhHfopR*z7nc%{|9yz^8)i^?TR0-2G91A|n8}8AL60^#)8(L*^@Dh&|tQMz|c}jt~sHh^!MeySu=dpsX0xX=p z4@jZ=fFBIf+{bVz*ud*P1Bsg~-8@Ity8o0gs)o59qyza?bqP7o8|4>3=z@8bbepJVox34@r@WOX=f}ghu&dT>oyW%gajN10Ut+QbH-1Qna8A zB5j^d7I)J}F-Uz7Q_{Y58QNuQP)jMv-6x;9r|dV#%%e!VPoBM}93S4Zg@q(^o!nip z476HuTdygq0Egp2x}=3 zh3`bkl_*Fn&sTS@%R&im8nm52E1xTh#l2iBVeZm3#cPXK7q?Zc!b9BUWyLj~HhARL z8Iiojtho5*VmH3|&}U~Tqr)_2u~5o~wGz&2Q=Y&-FsjPxPW*y>Opi?h4Gh`p2HDpK~p#_?$k6x$?BV zoqF|Ay~^_%G5LG-3Qm1`)jkPSrUAXuzU8q~D7XBS=dt>$`b?6zLyzj)k#V_}&eV1H zqDS=-Xy`-wk~&npPG3w)o_F>6q_ahzaZK0txn?62pV~pAHsrMJFgLYrZKahKELzY$ z9TS^-tUl~|*K?(LDHt9uLkGsR;f)w(8m= zcJk9moqeds%ElRod|jwFkqX)Ts^MHX5(kw#(n9fsHOX0hwot(yHDvfEHqhUl==PPz z-kor2(Y#P&6-@1OHKYRWom1*p19!0*Y{W57s*!kExhz1EMv1F=yOPpqRl^`8&@2%0 zj}q;Z)UbM|=HVQ~;Rt?IuX+!l@Bw5rtX8Udy~58RGgW)P$Mvh&0l&~ZB?#XKH#VlwCx z)8JR8!OsIHf1G~40-V}qG>gJ9LgDG3rYYw`;D*%6BzYKsmbY+*vox*M3}+$ zh-u@l4WJzxWn;U5PVSjC?QSzfyJqo}H^XtWGa7Hly*+Hl6L{97`dBF5-4nHJE9|SE zT7x$FM(|il1P|ePXD1G^js%|6W;oT|eF!EQ97ZJ(J4;pG&Bbs*3?twto_ge^X>Pi$ zd0VU5y1m834&Ii1+ncwwZ3K)bj@cTJ(m=~?%-p5y?sQJO zR4x{`EnjCWdVPsFKmR_fOZN7zFl-eENBK3td};T367e1@VIPuE^MRFOEua@NrK>tvFN6hs(4ZS07qswWm5^7mRh{nwD%N))80v zV0$~p#frnffUr~^QB+xiarzTkH=F+fL+}3!@Wbtjr{j3@K}pfYf=wUQ{a*n-WN>Rw z+fVm@UX(uRW~P;3{uS@gRs9!b{fg4KiIS=}eIFGt^Mhi7o~}QwC=Jfa3Tb(QvdW$& zxRe6;QI)EGwT_{vTDKrwN>2ar8immsfwEWY0*b2mDgTw8qWfV_YYvK6>kf)i`IMag z3luM*kfE}by;}EBv|l=`>UXxE-ouk@1Adg$I*Ovh92GhgGpBt&FsdRSKc3WcP*Un& znMwJfu+JltX>Uk7MTeB4q>kd*F^9bxUnsi4QK7O|#eUgguf}hRs`WFa?VuMZcA4jJ&h{r+|Hs(f=+= zdqt^#WhSTnIS4cFA3GNbZAJZ=#>hME{{~p5{gAX*)Nt54+y4gS7@hKKm{isLNBw^u zXMKuS^j~1(&9GPVt=DU*v`_o1>=b<;I@I^&Z7V(BN&kN*Iyp#m{ZdkPsvmv~j8v5U z@Osi>Y`9L)WrC!S%3e`=AD3yb)=fvH{ob^t$S6BSiyZcTztHp73py-F`e>wcB2xx? zDogpF9%nBX@|_NS!@=`c(7A0zK?wrPc z%Q|6jM%pQ&>@umN3a&aX?H`iy`wUQem!kTedj8UTmvrCZmf|qfEa)4K!d1OWwH%qL Q><_jG4VuSiCI`#@1NZH=SO5S3 literal 0 HcmV?d00001 diff --git a/c/aritmeticaptr/main.c b/c/aritmeticaptr/main.c new file mode 100644 index 0000000..47ee18c --- /dev/null +++ b/c/aritmeticaptr/main.c @@ -0,0 +1,60 @@ +/* +* Enunciado del Ejercicio: Modificación de Arreglos mediante Aritmética de Punteros +* +* Objetivo: +* Practicar el manejo de punteros y su relación con los arreglos estáticos en el lenguaje C, +* aplicando aritmética de punteros para recorrer y modificar los elementos almacenados en memoria. +* +* Descripción: +* +* Escribe un programa completo en C que realice las siguientes tareas: +* +* Declaración e Inicialización: +* +* Declara un arreglo estático de 5 enteros (int) e inicialízalo +* con valores arbitrarios de tu elección (por ejemplo: 5, 10, 15, 20, 25). +* +* Declara un puntero a entero (int *ptr) que apunte al inicio del arreglo. +* +* Procesamiento con Aritmética de Punteros: +* +* Utiliza un bucle (for o el de tu preferencia) para recorrer el arreglo únicamente mediante +* aritmética de punteros y el operador de indirección en la forma *(ptr + i) (o incrementando el puntero directamente). +* +* Dentro del bucle, suma 10 al valor actual almacenado en cada posición del arreglo. +* +* Salida por Consola: +* +* Muestra en pantalla los valores del arreglo antes y después de aplicar la modificación +* para verificar que el cambio se realizó correctamente en la memoria del arreglo original. +* +* Restricciones: +* +* Está prohibido utilizar la notación de corchetes (arreglo[i]) para acceder o modificar +* los elementos del arreglo dentro del bucle. Debes usar estrictamente la sintaxis de punteros (*(ptr + i)). +*/ + +#include + +#define V_LENGTH 5 + +void print_arr(int *); + +int main(void){ + int v1[V_LENGTH] = {5, 10, 15, 20, 25}; + int* ptr_v1 = v1; + print_arr(ptr_v1); + for(int i=0; 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 literal 0 HcmV?d00001 diff --git a/c/constptr/main.c b/c/constptr/main.c new file mode 100644 index 0000000..397de29 --- /dev/null +++ b/c/constptr/main.c @@ -0,0 +1,25 @@ +/* +* El objetivo es escribir un codigo donde falle al intentar modificar el contenido de un puntero +* y tambien falle al intentar modificar a donde apunta otro puntero. +*/ + + +int main(void){ + int sensor_temp = 25; + int sensor_humedad = 60; + int ipa = 192; + int ipb = 168; + const int *ptr_lectura = &sensor_temp; + int * const ptr_config = &ipa; + + ptr_lectura = &sensor_humedad; + + //No debo poder modificar el valor del sensor mediante el puntero. + *ptr_lectura = 44; + + *ptr_config = 10; + + //No debo poder cambiar a donde apunta el puntero ptr_config. + ptr_config = &ipb; + return 0; +} diff --git a/c/pipes1/err.txt b/c/pipes1/err.txt new file mode 100644 index 0000000..4528d91 --- /dev/null +++ b/c/pipes1/err.txt @@ -0,0 +1,4 @@ +Se encontraron 3 registros invalidos. +Iniciando reporte. +Procesando 128 registros. +Reporte generado correctamente. diff --git a/c/pipes1/errores.txt b/c/pipes1/errores.txt new file mode 100644 index 0000000..d60e891 --- /dev/null +++ b/c/pipes1/errores.txt @@ -0,0 +1 @@ +Se encontraron 3 registros invalidos. diff --git a/c/pipes1/listado.txt b/c/pipes1/listado.txt new file mode 100644 index 0000000..09f7e7c --- /dev/null +++ b/c/pipes1/listado.txt @@ -0,0 +1,7 @@ +Permissions Size User Date Modified Name +.rw-r--r-- 38 horacio 28 Oct 10:58 errores.txt +.rw-r--r-- 0 horacio 28 Oct 11:07 listado.txt +.rw-r--r-- 271 horacio 28 Oct 10:55 main.c +.rwxr-xr-x 16k horacio 28 Oct 10:56 programa +.rw-r--r-- 24 horacio 28 Oct 11:04 salida.txt +.rw-r--r-- 19 horacio 28 Oct 11:00 test.txt diff --git a/c/pipes1/main.c b/c/pipes1/main.c new file mode 100644 index 0000000..216a755 --- /dev/null +++ b/c/pipes1/main.c @@ -0,0 +1,9 @@ +#include +int main(void){ + fprintf(stdout, "Iniciando reporte.\n"); + fprintf(stdout, "Procesando 128 registros.\n"); + fprintf(stdout, "Reporte generado correctamente.\n"); + + fprintf(stderr, "Se encontraron 3 registros invalidos.\n"); + return 1; +} diff --git a/c/pipes1/programa b/c/pipes1/programa new file mode 100755 index 0000000000000000000000000000000000000000..a02e209556a804185d76804688b9f78f2634e113 GIT binary patch literal 16056 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 +int main(void){ + int c, count = 0, countbr = 0; + + while((c = getchar()) != EOF){ + if(c == '\n'){ + countbr++; + } + count++; + } + + fprintf(stdout, "Se leyeron %d bytes\n", count); + fprintf(stdout, "Se leyeron %d
\n", countbr); + + return 0; +} diff --git a/c/pipes2/programa b/c/pipes2/programa new file mode 100755 index 0000000000000000000000000000000000000000..13ca060853787bff796e7763208346dc67984778 GIT binary patch literal 16064 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 M%3oPhpybi|-;4^#>;M1& literal 0 HcmV?d00001 diff --git a/c/pipes3/entrada.txt b/c/pipes3/entrada.txt new file mode 100644 index 0000000..85857a8 --- /dev/null +++ b/c/pipes3/entrada.txt @@ -0,0 +1,2 @@ +este es un archivo +de texto diff --git a/c/pipes3/main b/c/pipes3/main new file mode 100755 index 0000000000000000000000000000000000000000..93307ebd7496d85c851ace9b123b26f8060f7672 GIT binary patch literal 19160 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 +#include +#include + +int count_words(char*); + +int main(void){ + + char buffer[50]; + int total_words = 0; + + while((fgets(buffer, sizeof(buffer), stdin)) != NULL){ + total_words += count_words(buffer); + } + + printf("El total de palabras es: %d\n", total_words); + + return 0; +} + +int count_words(char* line){ + int palabras = 0; + bool hay_espacio = false; + + printf("line: %s", line); + + if((line[0] != ' ') && strlen(line) > 0){ + palabras++; + } + + for(int i = 0; i < strlen(line); i++){ + if(line[i] == ' '){ + hay_espacio = true; + } + + if((line[i] != ' ') && (line[i] != '\n') && (hay_espacio)){ + palabras++; + hay_espacio = false; + } + } + return palabras; +} diff --git a/c/pipes3/programa b/c/pipes3/programa new file mode 100755 index 0000000000000000000000000000000000000000..3d1eda8c4a3bbbfa0a7436ea40c8509eb4e0de27 GIT binary patch literal 48048 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 M%3oPhpybi|-;4^#>;M1& literal 0 HcmV?d00001 diff --git a/c/struct1/main.c b/c/struct1/main.c new file mode 100644 index 0000000..fdf4e39 --- /dev/null +++ b/c/struct1/main.c @@ -0,0 +1,69 @@ +/* + * EJERCICIO DE LENGUAJE C: STRUCTS Y PUNTEROS + * + * 1. Define una struct llamada Coordenada que contenga dos campos enteros: x e y. + * 2. Implementa una función constructora llamada Coordenada* crear_coordenada(int x, int y) que: + * - Reserve memoria dinámicamente utilizando malloc para una nueva estructura Coordenada. + * - Verifique si la reserva de memoria fue exitosa. + * - Inicialice sus campos x e y con los valores pasados como parámetros. + * - Devuelva el puntero a la estructura creada. + * 3. En la función main: + * - Utiliza la función constructora para crear una coordenada. + * - Muestra por pantalla los valores iniciales utilizando el operador flecha (->). + * - Modifica los valores de los campos de la estructura utilizando también el operador flecha (->). + * - Muestra los nuevos valores por pantalla. + * - Libera la memoria reservada dinámicamente utilizando free para evitar pérdidas de memoria. + */ + +#include +#include + + +typedef struct{ + int x; + int y; +}Coordenada; + +Coordenada* crear_coordenada(int x, int y); +void modificar_coordenada(Coordenada**, int x, int y); +void imprimir_coordenada(Coordenada**); + +int main(void){ + + Coordenada* cord = crear_coordenada(10, 20); + + imprimir_coordenada(&cord); + modificar_coordenada(&cord, 30, 40); + imprimir_coordenada(&cord); + + free(cord); + + return 0; +} + +Coordenada* crear_coordenada(int x, int y){ + Coordenada* new_cord = malloc(sizeof(Coordenada)); + if(new_cord == NULL){ + perror("No se pudo crear la coordenada\n"); + exit(1); + } + + new_cord->x = x; + new_cord->y = y; + + return new_cord; +} + +void modificar_coordenada(Coordenada** cord_address, int x, int y){ + if((*cord_address) == NULL){ + perror("No se ha proporcionado una coordenada para modificar\n"); + exit(1); + } + (*cord_address)->x = x; + (*cord_address)->y = y; +} + +void imprimir_coordenada(Coordenada** a){ + printf("Coordenada(%d, %d);\n", (*a)->x, (*a)->y); +} + diff --git a/c/struct1/programa b/c/struct1/programa new file mode 100755 index 0000000000000000000000000000000000000000..7ac7461a66d905d9e28603e6072a8a72668f81a2 GIT binary patch literal 16360 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 vn2!U7LuGCcKbLV{%Wa3EPh&VC1$rbDoa + +#define P_LENGTH 3 + +typedef struct{ + char* nombre; + int edad; +}Persona; + +void listar_personas(Persona*, int length); +void cambiar_edad(Persona *p, int nueva_edad); + +int main(void){ + + Persona personas[P_LENGTH] = { + { + .nombre = "Horacio", + .edad = 43 + }, + { + .nombre = "Raquel", + .edad = 44 + }, { + .nombre = "Luna", + .edad = 15 + } + }; + + listar_personas(personas, P_LENGTH); + cambiar_edad(personas, 21); + cambiar_edad(personas+1, 22); + cambiar_edad(personas+2, -5); + listar_personas(personas, P_LENGTH); + + return 0; +} + +void listar_personas(Persona* p, int length){ + for(int i=0; i < length; i++){ + printf("%s \t %d \n", (p+i)->nombre, (p+i)->edad); + } +} + +void cambiar_edad(Persona *p, int nueva_edad){ + p->edad = nueva_edad; +} + diff --git a/c/struct2/programa b/c/struct2/programa new file mode 100755 index 0000000000000000000000000000000000000000..f428a07a7114730b752d138ee350d7847275cd95 GIT binary patch literal 16104 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 YP`R}0YH3V9v;SQBV*{-YI0QuXPf!M_9RL6T literal 0 HcmV?d00001 diff --git a/c/struct3/main.c b/c/struct3/main.c new file mode 100644 index 0000000..450fa79 --- /dev/null +++ b/c/struct3/main.c @@ -0,0 +1,347 @@ +/* ========================================================================= + * PROYECTO: Sistema de Registro y Telemetría para el Nanosatélite "Andrómeda-1" + * ------------------------------------------------------------------------- + * CONTEXTO: + * La Agencia Espacial Experimental está desarrollando el software de a bordo + * para su próximo nanosatélite. El sistema necesita gestionar memoria de + * forma dinámica y eficiente debido a los recursos limitados del microcontrolador + * y a la naturaleza impredecible de las ráfagas de datos en órbita. + * + * OBJETIVO: + * Diseñar e implementar un programa en lenguaje C que resuelva los siguientes + * módulos de gestión de memoria dinámica requeridos por la estación de tierra: + * + * 1. Vector Dinámico Básico (Canales de Sensores): + * Pide al operador un número N de canales activos, utiliza malloc para + * reservar un arreglo de enteros con las lecturas iniciales, muéstralo en + * consola y libera correctamente la memoria con free al terminar. + * + * 2. Cadenas Dinámicas (Identificadores de Misión): + * Escribe una función que reciba una cadena estática (char *) con el nombre + * de código del satélite, calcule su longitud exacta, reserve espacio + * dinámicamente con malloc, copie la cadena y devuelva el nuevo puntero + * dinámico para ser registrado en los logs del sistema. + * + * 3. Estructura Dinámica (Buffer de Archivos de Telemetría): + * Define una struct Archivo que contenga dos campos: size_t tamano y + * uint8_t *datos. Escribe una función que reciba el tamaño deseado y reserve + * memoria dinámicamente tanto para la estructura en sí como para su búfer + * interno de datos binarios. + * + * 4. Redimensionamiento con realloc (Stream de Datos en Tiempo Real): + * Crea una rutina que lea números enteros (paquetes de telemetría) desde + * la consola de forma indefinida hasta una condición de parada. Almacénalos + * en un arreglo dinámico que duplique su tamaño cada vez que se llene + * utilizando realloc para optimizar el almacenamiento. + * + * 5. Estructuras Anidadas Dinámicas (Subsistemas del Satélite): + * Crea una estructura principal (por ejemplo, MisionEspacial) que contenga + * un puntero a un arreglo dinámico de subestructuras (representando varios + * subsistemas como energía, propulsión y comunicación). Asegúrate de + * implementar un protocolo estricto de liberación en orden inverso + * (primero las subestructuras internas y sus recursos, luego el arreglo + * principal) para evitar fugas de memoria (memory leaks) críticas en órbita. + * + * REQUISITOS TÉCNICOS: + * - Uso obligatorio de las funciones de (malloc, realloc, free). + * - Validación de punteros (verificar que no sean NULL tras cada reserva). + * - Código limpio, modularizado en funciones y bien comentado. + * ========================================================================= */ + +#include +#include +#include +#include +#include +#include + +typedef struct{ + size_t size; + uint8_t *datos; +}TelemetryFile; + +typedef struct{ + TelemetryFile base; + size_t offset; +}TelemetryArray; + +typedef struct{ + int n_chanels; + int* chanels; + TelemetryFile* telemetry_file; + TelemetryArray telemetry_array; +}ProgramData; + + +void print_menu(ProgramData *); +void print_data(ProgramData *); +void get_nchanels(ProgramData *); +void get_chanels(ProgramData *); + +void get_telemetry_file(ProgramData *); +TelemetryFile* telemetry_file_create(size_t fs); +void telemetry_file_free(ProgramData *); + +void get_telemetry_data(ProgramData *); +bool telemetry_array_is_full(ProgramData *); +void telemetry_array_alloc(ProgramData *); +void telemetry_array_free(ProgramData *); +void telemetry_array_set(ProgramData *, uint8_t data); + +void free_data(ProgramData*); +void pause(void); + + +int main(void){ + + ProgramData data = { + .n_chanels = 0, + .chanels = NULL, + .telemetry_file = NULL, + .telemetry_array = { + .base = { + .size = 0, + .datos = NULL + }, + .offset = 0 + } + }; + + print_menu(&data); + + free_data(&data); + + return 0; +} + +void print_menu(ProgramData* ref_data){ + + int option = 0; + int exit = 0; + + system("clear"); + printf("MENU DE OPCIONES\n"); + printf("\t 1- Cargar canales\n"); + printf("\t 2- Mostrar Datos\n"); + printf("\t 3- Crear archivo de telemetría\n"); + printf("\t 4- Recibir telemetria\n"); + printf("\t 5- Salir\n"); + + scanf("%d", &option); + + switch (option) { + case 1: + get_nchanels(ref_data); + get_chanels(ref_data); + break; + case 2: + print_data(ref_data); + break; + case 3: + get_telemetry_file(ref_data); + break; + case 4: + get_telemetry_data(ref_data); + break; + case 5: + exit = 1; + break; + } + + if(!exit){ + print_menu(ref_data); + } + +} + +void get_telemetry_data(ProgramData *ref_data){ + system("clear"); + printf("RECEPCION DE TELEMETRIA\n"); + uint8_t read_data; + + do{ + printf("\nIngresar valor (0 para terminar):"); + scanf("%" SCNu8, &read_data); + + //printf("Se ha leido: %" SCNu8 "\n", read_data); + + if(read_data > 0){ + telemetry_array_set(ref_data, read_data); + } + + }while(read_data > 0); +} + +bool telemetry_array_is_full(ProgramData *ref_data){ + + uint8_t* start_add = ref_data->telemetry_array.base.datos; + + if(start_add == NULL){ + return true; + } + + uint8_t* end_add = start_add + ref_data->telemetry_array.base.size; + uint8_t* test_add = start_add + ref_data->telemetry_array.offset; + return test_add >= (end_add); +} + +void telemetry_array_alloc(ProgramData *ref_data){ + //Si esta vacio reserva espacio para uno. + if(ref_data->telemetry_array.base.datos == NULL){ + ref_data->telemetry_array.base.datos = malloc(sizeof(uint8_t)); + if(ref_data->telemetry_array.base.datos == NULL){ + perror("Error asignando memoria para streaming de telemetria."); + exit(1); + } + ref_data->telemetry_array.base.size = 1; + ref_data->telemetry_array.offset = 0; + return; + } + + uint8_t* result = realloc(ref_data->telemetry_array.base.datos, ref_data->telemetry_array.base.size * 2); + + if(result == NULL){ + perror("Error reasignando memoria para streaming de telemetria."); + exit(1); + } + + ref_data->telemetry_array.base.datos = result; + ref_data->telemetry_array.base.size *= 2; + + printf("La nueva capacidad es: %zu \n", ref_data->telemetry_array.base.size); +} + +void telemetry_array_free(ProgramData *ref_data){ + if(ref_data->telemetry_array.base.datos == NULL){ + free(ref_data->telemetry_array.base.datos); + ref_data->telemetry_array.base.datos = NULL; + } +} + +void telemetry_array_set(ProgramData *ref_data, uint8_t data){ + if(telemetry_array_is_full(ref_data)){ + printf("Esta lleno, vamos a agrandar \n"); + telemetry_array_alloc(ref_data); + } + + *(ref_data->telemetry_array.base.datos + ref_data->telemetry_array.offset) = data; + ref_data->telemetry_array.offset += 1; +} + + +void get_telemetry_file(ProgramData *ref_data){ + + size_t fs; + + system("clear"); + + printf("CREAR ARCHIVO DE TELEMETRIA\n"); + printf("\tEnter de size in bytes:"); + scanf("%zu", &fs); + + telemetry_file_free(ref_data); + ref_data->telemetry_file = telemetry_file_create(fs); + +} + +void telemetry_file_free(ProgramData *ref_data){ + if(ref_data->telemetry_file != NULL){ + if(ref_data->telemetry_file->datos != NULL){ + free(ref_data->telemetry_file->datos); + ref_data->telemetry_file->datos = NULL; + } + free(ref_data->telemetry_file); + ref_data->telemetry_file = NULL; + } +} + +TelemetryFile* telemetry_file_create(size_t fs){ + TelemetryFile* telemetry_file = malloc(sizeof(TelemetryFile)); + + if(telemetry_file == NULL){ + perror("Error creating telemetry file."); + exit(1); + } + + telemetry_file->size = fs; + telemetry_file->datos = malloc(sizeof(uint8_t)*fs); + + if(telemetry_file->datos == NULL){ + free(telemetry_file); + telemetry_file = NULL; + perror("Error allocating memory for the buffer to telemetry file."); + exit(1); + } + + return telemetry_file; + +} + +void get_nchanels(ProgramData* ref_data){ + system("clear"); + int n_chanels = 0; + printf("Cantidad de canales: "); + scanf("%d", &n_chanels); + + ref_data->n_chanels = n_chanels; + +} + +void get_chanels(ProgramData* ref_data){ + if(ref_data->chanels != NULL){ + free(ref_data->chanels); + ref_data->chanels = NULL; + } + ref_data->chanels = malloc(sizeof(int)*ref_data->n_chanels); + if(ref_data->chanels == NULL){ + perror("No se pudo reservar memoria para los canales."); + exit(1); + } + for(int i=0; i < ref_data->n_chanels; i++){ + int chanel; + printf("Frecuacia en Mhz del canal%d:", i); + scanf("%d", &chanel); + *(ref_data->chanels + i) = chanel; + } +} + +void print_data(ProgramData* ref_data){ + system("clear"); + printf("DATOS DEL PROGRAMA\n"); + printf("Cantidad de canales: %d\n", ref_data->n_chanels); + + for (int i=0; i < ref_data->n_chanels; i++){ + printf("\t CH %d Mhz\n", *(ref_data->chanels + i)); + } + + if(ref_data->telemetry_file != NULL){ + printf("Archivo de telemetria creado. Size: %zu bytes.\n", ref_data->telemetry_file->size); + } + + printf("Datos de telemetria: "); + for(size_t i=0; i < ref_data->telemetry_array.offset; i++){ + printf("%" SCNu8 ", ", *(ref_data->telemetry_array.base.datos + i)); + } + if(ref_data->telemetry_array.base.size == 0){ + printf("No hay datos."); + } + printf("\n"); + pause(); +} + +void free_data(ProgramData* ref_data){ + if(ref_data->chanels){ + free(ref_data->chanels); + } + telemetry_file_free(ref_data); + telemetry_array_free(ref_data); +} + +void pause(void){ + // 1. Limpiamos el búfer por si quedó algún caracter pendiente del scanf anterior + int c; + while ((c = getchar()) != '\n' && c != EOF); + // 2. Mostramos el mensaje y esperamos a que el usuario presione Enter de verdad + printf("Presione Enter para continuar...\n"); + getchar(); +} diff --git a/c/struct3/programa b/c/struct3/programa new file mode 100755 index 0000000000000000000000000000000000000000..554a79471ac52115bd457a94beef2b6033429864 GIT binary patch literal 17104 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 UPCX8am_n%d4_<}t$^ZZW literal 0 HcmV?d00001 diff --git a/c/swap/main.c b/c/swap/main.c new file mode 100644 index 0000000..e3c101a --- /dev/null +++ b/c/swap/main.c @@ -0,0 +1,28 @@ +#include + +void swap(char **, char**); +void swap_int(int *, int *); + +int main(void){ + char *s1 = "Hola"; + char *s2 = "Mundo"; + int n1 = 10; + int n2 = 20; + swap(&s1, &s2); + swap_int(&n1, &n2); + printf("s1: %s s2: %s\n", s1, s2); + printf("n1: %d n2: %d\n", n1, n2); + return 0; +} + +void swap(char **s1, char **s2){ + char *aux = *s1; + *s1 = *s2; + *s2 = aux; +} + +void swap_int(int* n1, int* n2){ + int aux = *n1; + *n1 = *n2; + *n2 = aux; +} diff --git a/c/swap/programa b/c/swap/programa new file mode 100755 index 0000000000000000000000000000000000000000..623d92d0bb00167538a92cd31348243a3a330d8a GIT binary patch literal 16088 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 + +void cambiar_puntero(int**, int*); + +int main(void){ + + int x = 20, y = 30; + int* ptr = &x; + + printf("contenido de ptr = %d \n", *ptr); + + cambiar_puntero(&ptr, &y); + + + printf("contenido de ptr = %d\n", *ptr); + +} + +void cambiar_puntero(int** ptr, int *address){ + *ptr = address; +} diff --git a/c/swap2/programa b/c/swap2/programa new file mode 100755 index 0000000000000000000000000000000000000000..e11628f60ae47827ef3cfc4676ce64cbc0218345 GIT binary patch literal 16064 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