Mensajes

[%p]

¿para que sirve usar (void*) ahí?

El especificador de formato %p espera un argumento de tipo void*, por lo tanto es necesario el cast.

¿Qué pasa si yo hago esto?

Al omitir el cast tu aplicacion queda expuesta a comportamiento indefinido.

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main(void)
{
    int matriz[4][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
    int x = 0, y = 0, i;

    for(;;)
    {
        printf("%*s", ((y == 0) ? 3 - x : y) * 2, "");
        for(i = 0; x - i >= 0 && y + i < 4  ; i++)
        {
            printf("%3d ", matriz[x - i][y + i]);
        }
        printf("\n");
        if(x < 3)
            ++x;
        else if(y < 3)
            ++y;
        else
            break;
    }
    return 0;
}

La utilización de GOTO está considerada una mala práctica de programación, la cual lleva a un código "espagueti".

Deberías leerte este articulo escrito por Edjer Dijkstra para una publicación de la ACM en 1968

Siempre los anti-goto citan directamente el articulo de Edsger Dijkstra's para justificar su posición de rechazo hacia goto. Lastima que el articulo de Dijkstra's prácticamente no tiene nada que ver con la forma de que goto es utilizado estos días, por lo tanto lo que dice el articulo tiene poca o ninguna aplicabilidad en la escena de programación moderna.

Uno puede llegar a escribir código difícil de leer sin usar goto, por lo tanto no es la
característica del lenguaje la que conduce a un código ilegible e imposible de mantener ni tampoco la sintaxis mas bien son los malos programadores los que causan esto.

Evitar usar goto porque quiere evitar producir código ilegible no tiene sentido si su código goto es legible, entonces no hay nada malo en ello, el problema viene cuando se abusa de ellos. Por lo que todo esto me lleva a la conclusión de que todo este rechazo hacia goto es solo un modismo establecido no porque algunos programadores lo usen de manera ineficiente yo debería evitar usarlo.

Saludos!

goto no deja de ser un ciclo (terriblemente aplicado)

A que te refieres con terriblemente aplicado?

Tambien puedes usar goto de esta forma

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main(void)
{
    char str[] = "Pablito clavo un clavito en la calva de un calvito";
    size_t i = 0;

start:
    if (str[++i] == '\0')
        goto end;
    if (str[i] == ' ')
        str[i] = '\n';
    goto start;
end:
    printf("%s\n", str);

    return 0;
}


Muchas gracias por el enlace son unos crack con Google por aqui xD .. la verdad no recuerdo de donde la saque pero era un foro en ingles, ahora voy a leer la pagina que me pasaste..

Me he encontrado un codigo en C++ muy extraño, el cual imprime una determinada contidad de numeros uno debajo de otro, hasta ahi todo normal pero lo hace sin usar ningun tipo de bucles ni recursión.

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using namespace std;

template<int N>
class PrintOneToN
{
public:
   static void print()
   {
       PrintOneToN<N-1>::print();  // Note that this is not recursion
       cout << N << endl;
   }
};

template<>
class PrintOneToN<1>
{
public:
   static void print()
   {
       cout << 1 << endl;
   }
};
int main()
{
   const int N = 100;
   PrintOneToN<N>::print();
   return 0;
}

Alguien entiendo como funciona este codigo?. Si es asi podria explicarme porfavor ..

Otra aproximación con la correspondiente liberación de memoria del array de estructuras y algunas que otras mejoras

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef struct Persona
{
    char *nombre;
    int edad;
    int sexo;
} Persona;

typedef struct
{
    Persona *array;
    size_t used;
    size_t size;
} Array;

void initArray(Array *a, size_t initialSize)
{
    a->array = (Persona*)calloc(initialSize , sizeof(Persona));
    a->used = 0;
    a->size = initialSize;
}

void push_back(Array *a, Persona element)
{
    if (a->used == a->size)
    {
        a->size *= 2;
        a->array = (Persona *)realloc(a->array, a->size * sizeof(Persona));
        memset(&a->array[a->used],0,sizeof(Persona) * (a->size - a->used));
    }
    a->array[a->used].nombre = (char*)malloc(strlen(element.nombre) + 1);
    strcpy(a->array[a->used].nombre, element.nombre);
    a->array[a->used].edad = element.edad;
    a->array[a->used].sexo = element.sexo;
    a->used++;
}

void freeArray(Array *a)
{
    int i;
    for (i = 0; i < a->used; i++)
    {
        free(a->array[i].nombre);
        a->array[i].nombre = NULL;
    }
    free(a->array);
    a->array = NULL;

    a->used = 0;
    a->size = 0;
}

void cargarPersonas(Array * arr)
{
    int i, edad, random;
    int TAM = rand() % 30 + 1;
    Persona temp;

    char *hombres[] = {"Ramiro","Pedro","Federico","Jose","Antonio","Pablo","Raul","Gustavo","Gonzalo","Airton"};
    char *mujeres[] = {"Mariana","Jennifer","Luz","Roxana","Ana","Sol","Micaela","Romina","Melina","Camila"};

    for ( i = 0; i < TAM; i++)
    {
        edad = rand() % 80 + 1;
        temp.edad = edad;
        if( (random = rand() % 10) % 2 == 0)
        {
            temp.nombre = hombres[random];
            temp.sexo = 0;
        }
        else
        {
            temp.nombre = mujeres[random];
            temp.sexo = 1;
        }
        push_back(arr, temp);
    }
}

void mostrarPersonas(Array *arr)
{
    int i;
    for ( i = 0; i < arr->used; i++)
    {
        printf("(%d) Nombre: %s - Edad: %d - Sexo: ", i, arr->array[i].nombre, arr->array[i].edad);
        if ( arr->array[i].sexo == 0)
            printf("Masculino");
        else
            printf("Femenino");
        printf("\n");
    }
}

int main(void)
{
    srand(time(NULL));
    Array a;
    initArray(&a, 5);

    cargarPersonas(&a);
    mostrarPersonas(&a);

    freeArray(&a);
    return 0;
}


Yo lo haría mas o menos así

Código (cpp) [Seleccionar] Expandir

#include <string.h>
#include <stdio.h>

int main(void)
{
    char str[64];
    int pos = 0, i, cant = 0;

    char *r = fgets(str, sizeof(str), stdin);
    char len = strlen(str);

    if(r != NULL && str[len - 1] == '\n')
       str[len - 1] = '\0';

    for (i = 0; str[i] != '\0'; i += pos + 1)
        if(((pos = strcspn( str + i, " " )) == 4))
            cant++;

    printf("Palabras con 4 letras son: %d\n", cant);

    return 0;
}


Otra aproximación seria haciendo uso de la función strchr y una tabla, con la que podríamos ubicar fácilmente cualquier letra inclusive la ñ, sin complicar demasiado el código.

Código (c) [Seleccionar] Expandir

int posicion(char c)
{
    const char * abc = "abcdefghijklmnñopqrstuvwxyz";
    const char * letra;

    c = tolower ((unsigned char)c);
    letra = strchr (abc, c);

    return letra ? letra - abc : -1;
}

Saludos