Mensajes

Los que se implementan dentro de la clase se convierten en métodos inline. Cada vez que el compilador encuentra uno no hace una llamada a ese método, sino que copia todo el código en ese lugar.
Por tanto los métodos inline se usan para hacer pequeños trabajos muy repetidos ya que no hay que perder tiempo llamándolos. Nótese que si el método inline es grande el código final va a crecer mucho, además por lo que es coste de tiempo en llamarlo al del tamaño del código objeto, a lo mejor, no compensa.

El implementarlo fuera sigue la filosofía de separar la declaración de la definición. Así la declaración va en un archivo de cabecera que puede pasarse al archivo de código que sea necesario. Mjentras tanto tienes por otra parte las definiciones en un código objeto que el enlazador te va a unir en último momento.
Esto te da la ventaja de reducir el tiempo de compilación porque sólo debes compilar el archivo que se ha cambiado y no todo el código.

Por cierto, no resucites hilos antiguos. Estaría mejot si iniciaras uno nuevo para la cuestión.

De nuevo te repito: Una vez que usas un puntero C pierde la pista al dato al que apunta. Tal y como te dice ivancea96 puedes crearte un tipo de dato que contenga un array y su tamaño o creas una función como la siguiente:

Código (c) [Seleccionar] Expandir


int arraylen(size_t type_length, size_t array_length) {
   return array_length / type_length;
}

Y lo llamas así:

Código (c) [Seleccionar] Expandir


int array[] = {1, 2, 3, 4, 5};
int n = arraylen(sizeof(int), sizeof array);


[charlen]

En tu función charlen has ocultado identificador x que nombra el array, por lo que dentro de la función éste ya no se ve.
Realmente lo que te he dicho es falso pues el array x en el momento de la definición de la función no existe así que es imposible que C sepa el tamaño de éste.
Para que el programa funcione debes hacer los siguientes cambios.

Código (c) [Seleccionar] Expandir


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

// Global variables

char x[]={'H','A','R','D','F','O','R','O'};
const char *y = "HARDFORO";

int charlen(){
return sizeof(x) / sizeof(x[0]);
}

int main(void){

int i;


for (i=0;i<charlen();i++)
printf("%c",x[i]); // HARDFORO
   
    putchar('\n');

for (i=0;i<strlen(y);i++)
printf("%c",y[i]); // HARDFORO
}

Un array no es un puntero. Son dos tipos de objetos diferentes. C sabe el tamaño que tiene un array pues se lo has indicado pero un puntero puede apuntar a cualquier cosa y no hay información sobre lo que guarda. Por tanto el tamaño de un puntero tan solo te devolverá el tamaño de la palabra del procesador.

Así mientras tengas la declaración del array a la vista de sizeof éste sabrá que tamaño tiene, en cuánto lo referencies con un puntero habrás terminado con ese dato.

¿Qué quiere decir eso?
Si declaras el array de forma global, fuera de toda función, a partir de ese momento todo el programa conocerá el tamaño del array.
Si declaras el array de forma local, dentro de una función, únicamente dentro de esa función se sabrá el tamaño de ese array.

Tienes Visual Studio Comunityt.
Tienes Mono Develop.
Tienes QtCreator.

Solución para Linux en compilador GCC, posiblemente funcione em MINGW para Windows ya que es un port de GCC.

El corazón del programa es la función getnum que sólo recibe números decimales (del 0 al 9) desde el teclado y devuelve un entero (int) con el valor igual al número introducido.

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <ctype.h>
#include <termios.h>

static struct termios old, new;

void init_terminal() {
    tcgetattr(0, &old); /* old <- configuración actual del terminal
                         * el 0 en el primer argumento es el descriptor
                         * de archivo de stdin.
                         */
    new = old;          /* new copia el terminal original */
    new.c_lflag &= ~ICANON;      /* Modo no canónico: la entrada se acepta
                                  * caracter a caracter en vez de línea a
                                  * línea.
                                  */
    new.c_lflag &= ~ECHO;        /* No hay eco del carácter introducido */
    tcsetattr(0, TCSANOW, &new); /* Se guarda el nuevo comportamiento
                                  * del terminal para usarlo a partir
                                  * de ya.
                                  */
}

void reset_terminal() {
    tcsetattr(0, TCSANOW, &old); /* Se vuelve al comportamiento original */
}

int getnum() {
    int num = 0;
    int pos = 0;
    int negative = 0;
    char c;
   
    init_terminal(0);
    while((c = getchar()) != '\n') {
        if(pos == 0 && c == '-') {
            putchar('-');
            negative = 1;
            ++pos;
        }
        if(c == 127 && pos) { /* 127 es la tecla retroceso */
            num /= 10;
            putchar('\b');
            putchar(' ');
            putchar('\b');
            --pos;
        }
        if(isdigit(c)) {
            putchar(c);
            num *= 10;
            num += c - '0';
            ++pos;
        }
    }
    if(negative)
        num = -num;
    reset_terminal();
    putchar('\n');
    return num;
}

int main()
{
    int num;
    printf("Introduzca un número: ");
    num = getnum();
    printf("%i", num);
   
    return 0;
}

Pues si estoy en casi lo correcto busca un juego, lo más sencillo que encuentres, del juego de la vida de Conway.
Trabajas de la siguiente forma:
Tienes un array que es tu mundo en el presente, en el momento T.
Tienes un array que representa tu mundo en el momento T+1.
Para rellenar éste último array lo que haces es a cada partícula de T aplicas los cálculos de física sobre todos sus vecinos en el momento T. A la partícula actualizada la guardas en el array de T+1.
Finalizadas todas las partículas copias T+1 a T, o mediante punteros (será más rápido) conviertes el array T+1 en el array T y el que era el T servirá para situar los datos de T+1, y lo presentas por pantalla, o lo que sea que tengas que hacer para representar los datos.
Vuelves a empezar.

A ver si entiendo el concepto que estás intentando realizar.
Tienes un conjunto de particulas en un entorno tridimensional, un cubo.
Por lo que veo en la definición de sus propiedades,  estas partículas van a interactuar entre sí unas con otras.
Has guardado tus partículas en un array, contienen la información en el momento t
Quieres otro array para que te guarde todas las partículas otra ves pero actualizadas al momento t+1.

Veo que C no es tu primer lenguaje.
Yo veo una tabla de structs
con datos definidos del siguiente estilo:
Un char[] con el tamaño suficiente como para contener una cadena de 3 caracteres, que contendrá el nombre del asiento. <-- Esto está mal. En su lugar debe poner:
Un char[] con el tamaño suficiente como para contener un DNI con su letra.
Un int usado como bool (soy de la vieja escuela) para saber si el asiento está ocupado.
No pondría el nombre del asiento en el struct porqué no lo veo útil. Lo que haría es una función que traduzca el nombre del asiento a un puntero hacia el elemento de la tabla a la que pertenece el asiento.



Editado, razón en el mensaje principal.

Esto es porque lo quieres compilar con C++. C, no se queja tanto por la igualdad en tipos de datos, C++ es muy estricto en eso.
malloc, calloc, realloc devuelven void*. C al ver esto se fija en el tipo de dato del lvalue y si puede hacer la conversión, la hace; en cámbio C++ no hace ese paso y entiende que el programador, al no hacer el cast explícito, se ha equivocado.

Código [Seleccionar] Expandir

int *p = malloc (sizeof (int));
Funciona en C pero en C++ necesita

Código [Seleccionar] Expandir

int *p = (int*) malloc (sizeof(int));