Mensajes

Como te decía, la estructura no debe guardar el IMC, lo debes sacar de forma que no se pueda modificar, y eso es con una función.

Algo así:

Código [Seleccionar] Expandir


float get_IMC(tPatient p) {
    return weight/(height*height);
}

Cada vez que en el código debas obtener el IMC de alguien usas la función.

¿Por qué? Imagínate que IMC se guarda en la estructura y la calculas:

Código [Seleccionar] Expandir

p.IMC = p.wheight/(height*height);

Ahora tienes en p.IMC el índice de masa corporal, pero eso no evita que en cualquier otro punto del programa se haga

Código [Seleccionar] Expandir

p.IMC = 25;

A partir de este momento el IMC será 25 porqué sí y no el resultado del cálculo.

A ver:
Dentro de una estructura no se puede poner código. Ahí intentas que IMC sea calculado por una operación matemática pero eso debes hacerlo en otro sitio.
Y aunque fuera C++, que sí permite código éste debe encapsulado en un método, no se puede escribir directamente.
Siendo coherentes con el código deberías eliminar todo lo referente al IMC de la estructura ya que si dejas allí la variable en cualquier momento se podría cambiar falseando el dato.

Haz una función que reciba la estructura, calcule la IMC a partir de sus datos y lo devuelva.

De todas formas veo algo raro con las funciones PrintPatient#(tPatient p#);
¿Las funciones hacen cosas diferentes? ya que tPatient, tPatient2 y tPatient3 son el mismo tipo de dato ¿porqué hay 3? Una cosa es el tipo de dato y la otra las variables.
Si las funciones PrintPatient# son todas iguales te basta que exista solo una y le vayas pasando las diferentes variables de los pacientes. Algo así:

Código [Seleccionar] Expandir


tPatient p1, p2, p3;

// Cargas los datos de p1, p2 y p3

PrintPatient(p1);
PrintPatient(p2);
PrintPatient(p3);


Bueno, creo que te has complicado un poco.
Empieza instalando un valor que indique que la casilla está vacía, yo he usado el 0 (aprovechando que 0 significa también false y cualquier otro número true).

El primer paso de meter el 5 y el 6 en la primera y última fila es muy sencillo ya que la matriz está vacía. Caigan donde caigan están bien.

Para incluir el 2 y el 3 tampoco tiene mucha complicación. Se corre la matriz por filas desde el inicio hasta penúltima fila. Por fila:
· Buscar una misma columna vacía para y e y+1
· En y incluir el 2.
· En y+1 incluir el 3.

Para incluir los entre números aprovecha las marcas de casilla vacía. Prepara una bandera para indicar si debes escribir los unos o no.

Por cada fila:
· desactiva la badnera
· Por cada columna:
  · Si la bandera está desactivada y la casilla no está vacía:
     · activa la bandera (Después de activar esa bandera no debes hacer nada y esperar a la siguiente iteración)
  · Y si no:
     · Si la casilla está vacía:
        · escribe un 1 en ella
     · Y si no:
        · termina el bucle columna

Para terminar de rellenar la matriz recórrela casilla por casilla. Si la casilla está vacía introduce 1 o 4 aleatoriamente.

Esto en C11 quedaría así:

Código (c) [Seleccionar] Expandir

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

/* Matriz global por lo que
* al crearla se llena de ceros ( 0 )
* así que aprovecharé eso para
* marcar la posición vacía
*/
#define FILAS 4u
#define COLUMNAS 6u

int matriz[FILAS][COLUMNAS];

// devuelve una casilla vacia aleatoria
// en la fila y del array
unsigned columna_vacia_en_fila(unsigned fila) {
    unsigned x;

    do {
        x = rand()%COLUMNAS;
    } while(matriz[fila][x] && matriz[fila+1][x]);

    return x;
}

// incluir el 5 en la primera fila
// y el 6 en la última fila
void incluir_5_6() {
    unsigned x;

    x = rand()%COLUMNAS;
    matriz[0][x] = 5;

    x = rand()%COLUMNAS;
    matriz[FILAS-1][x] = 6;
}

// incluir el 2 en fila y+1
// y el 3 en la fila y+1
void incluir_2_3() {
    unsigned x, y;

    for(y=0; y<FILAS-1; ++y) {
        x = columna_vacia_en_fila(y);
        matriz[y][x] = 2;
        matriz[y+1][x] = 3;
    }
}

// incluir el 1 entre dos números en una fila
// por cada fila
void incluir_1_entre() {
    unsigned x, y;
    bool escribir;

    for(y=0; y<FILAS; ++y) {
        escribir = false;
        for(x=0; x<COLUMNAS; ++x) {
            if(!escribir && matriz[y][x]) {
                escribir = true;
            }
            else {
                if(matriz[y][x]) break;
                else matriz[y][x] = 1;
            }
        }
    }
}

// rellenar indistintamente con 1
// y 4 las casillas que faltan
void incluir_1_4() {
    unsigned x, y;

    for(y=0; y<FILAS; ++y) {
        for(x=0; x<COLUMNAS; ++x) {
            if(matriz[y][x] == 0) {
                matriz[y][x] = rand()%2? 4 : 1;
            }
        }
    }
}

// imprimir la matriz
void imprimir() {
    unsigned x, y;

    for(y=0; y<FILAS; ++y) {
        for(x=0; x<COLUMNAS; ++x) {
            printf("%d ", matriz[y][x]);
        }
        puts("\n");
    }
}

int main() {
    srand(time(NULL));

    incluir_5_6();
    incluir_2_3();
    incluir_1_entre();
    incluir_1_4();

    imprimir();
}



Gracias a un dato apuntado por NEBIRE en la siguiente respuesta me he dado cuenta de algo que se me había pasado por alto: el 2 y el 3 deben estar en la misma columna.
Solucionado en la reedición.

Oky, muestra lo que tienes hecho.

No haces bien los case:
Tú escribes

Código [Seleccionar] Expandir

switch (opc3) {
    libras = cant * .0022;
    case 1:cout<<"libras: "<<libras<<endl;
    break;
    // ...

La línea en que calculas libras está en una dimensión desconocida, no hay manera a que el programa llegue a ella y la razón es que has puesto el case después.
Los case son puntos de entrada donde empezará la ejecución, así que es lo primero que debe aparecer.
Debe quedar así:

Código [Seleccionar] Expandir

switch (opc3) {
    case 1:
        libras = cant * .0022;
        cout<<"libras: "<<libras<<endl;
        break;
    // ...

Esto ya es un problema del compilador. Intenta reinstalándolo o usando otro.

Solo compila, no compiles y ejecutes, te debe aparecer un mensaje diciendo dónde falla tu código. El IDE suele tener una ventana que muestra la salida del compilador.

Por ejemplo, sobre tu fuente original:
||=== Build: Debug in pruebaC (compiler: GNU GCC Compiler) ===|
In function 'llenaVect':|
33|warning: format '%f' expects argument of type 'float *', but argument 2 has type 'double *' [-Wformat=]|
In function 'imprimaVect':|
40|warning: implicit declaration of function 'print' [-Wimplicit-function-declaration]|
In function 'productoPunto':|
48|error: 'V1' undeclared (first use in this function)|
48|note: each undeclared identifier is reported only once for each function it appears in|
48|error: 'V2' undeclared (first use in this function)|
50|error: expected ';' before '}' token|
||=== Build failed: 3 error(s), 2 warning(s) (0 minute(s), 1 second(s)) ===|

Línea 39, has escrito print en vez de printf.
Línea 48 y 49, nombras las variables V1 y V2 que no existen en esa función.

El compilador, a parte de decir que no compila también suele decir porqué.

Cómo ya te he dicho en otros mensajes sobre punteros, el nombre de un array es la dirección del primer elemento. Por eso lo puedes y debes asignar directamente.

De normal se hacen uso de setters, es decir, un función por variable que le dará valor. Además se suelen usar para que los rangos que acepta esa variable no sean superados, por ejemplo que la edad de una persona no sea negativa.