elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


  Mostrar Mensajes
Páginas: 1 2 3 4 [5] 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... 161
41  Programación / Programación C/C++ / Re: alguna forma de pasar una funcion miembro como argumento a otro miembro de clase? en: 3 Abril 2022, 01:47 am
A voz de pronto se me ocurre que alpha tuviera un flag que pueda activar beta (esto para evitar una recursión infinita). Si ese flag se activa a continuará con su ejecución, sino se repetirá desde el principio. No se C++, pero en C sería algo así:
Código
  1. #include <stdio.h>
  2. #include <stdbool.h>
  3.  
  4. bool beta() {
  5.    static int i=0;
  6.    puts("Ejecuto beta");
  7.    i++;
  8.    return i<5;
  9. }
  10.  
  11. void alpha() {
  12. void alpha() {
  13.    do {
  14.        puts("Ejecuto alpha");
  15.    } while(beta());
  16.    puts("Fin de alpha");
  17. }
  18.    puts("Fin de alpha");
  19. }
  20.  
  21. int main() {
  22.    alpha();
  23. }

Si no quieres usar el do/while puedes usar el goto (si no le tienes manía)
Código
  1. #include <stdio.h>
  2. #include <stdbool.h>
  3.  
  4. bool beta() {
  5.    static int i=0;
  6.    puts("Ejecuto beta");
  7.    i++;
  8.    return i<5;
  9. }
  10.  
  11. void alpha() {
  12.    inicio:
  13.    puts("Ejecuto alpha");
  14.    if(beta())
  15.        goto inicio;
  16.    puts("Fin de alpha");
  17. }
  18.  
  19. int main() {
  20.    alpha();
  21. }

O mediante setjmp/longjmp (no recomendado)
Código
  1. #include <stdio.h>
  2. #include <setjmp.h>
  3.  
  4. jmp_buf buf;
  5.  
  6. void beta() {
  7.    static int i=0;
  8.    puts("Ejecuto beta");
  9.    i++;
  10.    longjmp(buf, i);
  11. }
  12.  
  13. void alpha() {
  14.    if(setjmp(buf)<5) {
  15.        puts("Ejecuto alpha");
  16.        beta();
  17.    }
  18.    puts("Fin de alpha");
  19. }
  20.  
  21. int main() {
  22.    alpha();
  23. }
42  Programación / Programación C/C++ / Re: Ordenar lista doblemente enlazada con insertion sort en: 27 Marzo 2022, 20:26 pm
Sí, es un quebradero de cabeza. Mucho más sencillo cuando se usa un array.

Una solución que he conseguido es la siguiente. En C. Esas cosas modernas de C++ se me escapan :D

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4.  
  5. typedef struct node {
  6.    int data;
  7.    struct node* prev;
  8.    struct node* next;
  9. } node;
  10.  
  11. void print(node *list) {
  12.    node *pointer = list;
  13.    while(pointer) {
  14.        printf("%d ", pointer->data);
  15.        pointer = pointer->next;
  16.    }
  17.    putchar('\n');
  18. }
  19.  
  20. void insertion_sort(node **head) {
  21.    // evito una lista vacía
  22.    if(!*head) {
  23.        return;
  24.    }
  25.  
  26.    // se recorre la lista de izquierda a derecha
  27.    for(node *pointer=(*head)->next; pointer; pointer=pointer->next) {
  28.        // nodo auxiliar para recorrer la lista al revés en busca de datos menores
  29.        node *aux = pointer;
  30.        // flag para mantener pointer en su sitio
  31.        bool flag = true;
  32.        // ordenando de forma ascendente
  33.        while(aux->prev && aux->data < aux->prev->data) {
  34.            // se inicia el intercambio de nodos, el actual por el anterior a este ----------------
  35.            // se empieza por hacer que los nodos en los extremos de la pareja actual apunten
  36.            // a la pareja actual de forma intercambiada. Por ejemplo: sean los cuatro nodos
  37.            // A B [C] D
  38.            // C es el nodo actual a comparar
  39.            // A->next apunta a B
  40.            // D->prev apunta a C
  41.            // en el intercambio
  42.            // A->next debe apuntar a C
  43.            // D->prev debe apuntar a B
  44.            // para que esto sea así se debe comprobar que A y D existan para poder operar
  45.  
  46.            // contiene la dirección del nodo previo al previo del actual: siendo el actual C, A
  47.            node *app = aux->prev->prev;
  48.            // si dicho nodo existe, el siguiente a este deberá ser el actual. A->next apunta a C.
  49.            if(app) {
  50.                aux->prev->prev->next = aux;
  51.            }
  52.            // si existe un nodo que sea siguiente al actual, su previo debe apuntar al nodo anterior al actual. D->prev apunta a B.
  53.            if(aux->next) {
  54.                aux->next->prev = aux->prev;
  55.            }
  56.  
  57.            // intercambio entre la pareja de nodos.
  58.            // B->prev apunta a C
  59.            aux->prev->prev = aux;
  60.            // B->next apunta a D
  61.            aux->prev->next = aux->next;
  62.            // C->next apunta a B
  63.            aux->next = aux->prev;
  64.            // C->prev apunta a A
  65.            aux->prev = app;
  66.  
  67.            // el primer intercambio se hará lo más a la derecha de la sublista
  68.            // por lo tanto cuándo se efectua el primer intercambio se debe actualizar
  69.            // pointer para que apunte al nodo intercambiado. El flag va a evitar que
  70.            // si se va hacia la izquierda pointer también vaya a la izquierda.
  71.            if(flag) {
  72.                pointer = aux->next;
  73.                flag = false;
  74.            }
  75.  
  76.            // la cabeza de la lista se debe actualizar si hay algún nodo que ha caído en
  77.            // esa posición
  78.            if(!aux->prev)
  79.                *head = aux;          
  80.        }
  81.    }
  82. }
  83.  
  84. bool add(node **head, int data) {
  85.    node *new = malloc(sizeof(node));
  86.    if(!new) {
  87.        return false;
  88.    }
  89.  
  90.    new->data = data;
  91.    new->next = NULL;
  92.  
  93.    if(*head) {
  94.        node *pointer = *head;
  95.        while(pointer->next) {
  96.            pointer = pointer->next;
  97.        }
  98.        pointer->next = new;
  99.        new->prev = pointer;
  100.    } else {
  101.        new->prev = NULL;
  102.        *head = new;
  103.    }
  104.  
  105.    return true;
  106. }
  107.  
  108. void drop(node **head) {
  109.    node *aux;
  110.    if(!*head) {
  111.        return;
  112.    }
  113.  
  114.    while(*head) {
  115.        aux = *head;
  116.        *head = (*head)->next;
  117.        free(aux);
  118.    }
  119. }
  120.  
  121. int main() {
  122.    node *list = NULL;
  123.    add(&list, 5);
  124.    add(&list, 2);
  125.    add(&list, 4);
  126.    add(&list, 1);
  127.    add(&list, 3);
  128.    add(&list, 0);
  129.  
  130.    print(list);
  131.  
  132.    insertion_sort(&list);
  133.    print(list);
  134.  
  135.    drop(&list);
  136. }
43  Programación / Programación C/C++ / Re: ¿Como controlar punteros a estructuras y meterlo en una funcion? en: 26 Marzo 2022, 11:03 am
Sé que C++ tiene otra forma de hacer las cosas, con referencias y tal. No sé.

Pero en C sería algo así:
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. typedef struct node {
  5.    int data;
  6.    struct node* prev;
  7.    struct node* next;
  8. } node;
  9.  
  10. node* add(node **head, int data) {
  11.    node *new = malloc(sizeof(node));
  12.    if(!new) {
  13.        return NULL;
  14.    }
  15.  
  16.    new->data = data;
  17.  
  18.    if(*head) {
  19.        new->prev = (*head)->prev;
  20.        new->next = *head;
  21.        (*head)->prev->next = new;
  22.        (*head)->prev = new;
  23.    } else {
  24.        new->next = new;
  25.        new->prev = new;
  26.        *head = new;
  27.    }
  28.  
  29.    return new;
  30. }
  31.  
  32. void drop(node **head) {
  33.    node *aux;
  34.    if(!*head) {
  35.        return;
  36.    }
  37.  
  38.    (*head)->prev->next = NULL;
  39.    while(*head) {
  40.        aux = *head;
  41.        *head = (*head)->next;
  42.        free(aux);
  43.    }
  44. }
  45.  
  46. int main() {
  47.    node *list = NULL;
  48.    add(&list, 0);
  49.    add(&list, 1);
  50.    add(&list, 2);
  51.  
  52.    printf("%d ", list->data);
  53.    printf("%d ", list->next->data);
  54.    printf("%d ", list->prev->data);
  55.  
  56.    drop(&list);
  57. }
44  Programación / Programación C/C++ / Re: Ayuda con un ejercicio de Listas y Colas en: 17 Marzo 2022, 18:02 pm
Bonito trabajo. Adelante.
45  Programación / Programación C/C++ / Re: Tengo una duda sobre los punteros, trabajar con archivos, arrays y vectores. En c+++ en: 17 Marzo 2022, 17:58 pm
Pues no, no hay una forma rápida de hacerlo.
Tal vez en vez de querer ponerlo todo en un array o tabla de dos millones de filas que va consumir muchísima memoria, deberías pensar de trabajar con fracciones de 500 o de mi filas. Mucho más manejable y bastante más rápido en cargarlo en memoria.
46  Programación / Programación C/C++ / Re: Tengo una duda sobre los punteros, trabajar con archivos, arrays y vectores. En c+++ en: 16 Marzo 2022, 23:13 pm
Puedes decir que todos las cifras de esa tabla gigante tienen un número fijo de dígitos o es algo arbitrario? Lo digo porque si fueran todos de dos dígitos, como muestras en el ejemplo, con un poco de matemáticas sacas la dimensión de la tabla.
47  Programación / Programación C/C++ / Re: Tengo una duda sobre los punteros, trabajar con archivos, arrays y vectores. En c+++ en: 16 Marzo 2022, 16:14 pm
Creo que el fichero es tal cual y no puede modificar su estilo, como cuando en el trabajo te dicen: esto es lo que debes consumir y quiero que hagas esto.

Saltarse esa cabecera, en C++ no sé, pero en C sería:
Código
  1. fscanf(archivo, "%*d\n"
  2.                "%*d\n"
  3.                "%*d %*d\n"
  4.                "%*d %*d\n"
  5.                "%*d,%*d %*d,%*d %*d,%*d\n");

O si controlas las comas decimales mediante configuración de localización:
Código
  1. fscanf(archivo, "%*d\n"
  2.                "%*d\n"
  3.                "%*d %*d\n"
  4.                "%*d %*d\n"
  5.                "%*f %*f %*f\n");
48  Programación / Programación C/C++ / Re: Duda sobre nodos y uso de memoria en: 10 Marzo 2022, 18:53 pm
Esta línea te sobra
Código:
nodo *actual=new nodo();
porque le estás pidiendo al sistema memoria para un nodo que no usas. A la siguiente línea le cambias la referencia con
Código:
actual=lista;
y ya has perdido ese 'new nodo()'. Igual en 'eliminarnodo' debes hacer un delete, no basta con cambiar de referencia la pila.
49  Programación / Programación C/C++ / Re: Usar códigos escape ANSI en C es standard? en: 9 Marzo 2022, 13:29 pm
Son códigos del estándar POSIX, no es estándar de C.
50  Programación / Programación C/C++ / Re: Me cago en C/C++ en: 5 Marzo 2022, 21:29 pm
Va MAFUS no te molestes tanto, si en el titutlo los puse juntos, pero claramente hablo de ellos de forma separada.
No lo digo por ti, sino por el mundo entero, jejeje.
Páginas: 1 2 3 4 [5] 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... 161
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines