Mensajes

A lo que me refería era a qué me comentaras cómo habías planteado tú el ejercicio para usar las variables que habías creado. Es decir algo así como:

• creo un <char nombre[12]> para guardar el nombre del ingrediente.
  
• creo un <int precio_individual[400]> para...
  Es decir, que me explicaras cómo quieres usar tus variables ya que algunas de tus variables son un poco raras. Entonces quiero ver cómo lo tenías pensado para decirte qué variables debes usar para lo que quieres hacer.
  
  PD: El código de tu primer mensaje edítalo y pon el programa entre etiquetas de código GeSHi. Tiene que quedar algo así:
  
  Código (c) [Seleccionar] Expandir
  
// tus funciones
int main(){
    // tu codigo
}

Primero, el código  entre etiquetas GeSHi para que se pueda ver bien. Y en segundo lugar "ayuda a pasar un codigo de java a c++" no es lo mismo que "pasadme este código de java a c++".
El trabajo lo tienes que hacer tú, no nosotros.

Creo que eso es normal. Yo compilo también con ese comando en Ubuntu 18.04 LTS y los ejecutables también me los identifica como bibliotecas compartidas.
Texto sacado de wikipedia :

El formato ELF (Executable and Linkable Format) es un formato de archivo para ejecutables, código objeto, bibliotecas compartidas y volcados de memoria.

[Forma 1:]

Lo primero te recomiendo que pongas tu código entre etiquetas de código GeSHi, las puedes seleccionar encima del cuadro de texto que sale cuando escribes/modificas un mensaje. Sin ellas el código se hace ilegible.

Ahora respecto a lo que se puede sacar de ese código:
Las variables es preferible que las declares dentro del <main> para hacerlas locales, ya que tal y como lo has declarado tú son variables globales y no es muy seguro ni recomendable usarlas, excepto para algunos casos particulares.

Ahora me gustaría que me explicaras un poco que has querido crear con cada variable, es decir; qué uso le quieres dar a cada variable. Y ahora te doy una idea de cómo guardar los datos.

Tenemos unos ingredientes que son cadenas de caracteres <char*> con un precio <int> o <double> (mejor <double>). Entonces rápidamente se me ocurren dos formas de hacerlo, una usando un <struct> y otra sin hacer uso de <struct>:
Forma 1:
Creamos un <struct> llamado <Ingrediente> que tenga nombre y precio. Algo así:

Código (c) [Seleccionar] Expandir


const int TAM_NOMBRE = 20; // maximo numero de letras para el nombre de cada ingrediente
const int MAX_INGREDIENTES = 10; // numero de ingredientes que podemos almacenar

struct Ingrediente{
    char nombre[TAM_NOMBRE];
    double precio;
};

int main(){
    Ingrediente mis_ingredientes[MAX_INGREDIENTES];
    // el resto del codigo
}
Con esta opción creamos un nuevo tipo de dato llamado <Ingrediente> (como si fuera un <int>) que dentro de cada variable de tipo ingrediente tenemos guardado su nombre y su precio. Para acceder al ingrediente 2 (contando el 0), accederíamos mediante:

Código (c) [Seleccionar] Expandir


char nombre2[] = mis_ingredientes[2].nombre;
double precio2 = mis_ingredientes[2].precio;
Te recomiendo esta opción ya que deja la información más estructurada y es sencillo de ver.

Forma 2:
Creamos dos arrays (arreglos), uno para el nombre del ingrediente y otro para el precio:

Código (c) [Seleccionar] Expandir


const int TAM_NOMBRE = 20; // maximo numero de letras para el nombre de cada ingrediente
const int MAX_INGREDIENTES = 10; // numero de ingredientes que podemos almacenar
int main(){
    char nombre[MAX_INGREDIENTES][TAM_NOMBRE];
    double precio[MAX_INGREDIENTES];
    // el resto del codigo
}
Con esta segunda opción evitamos usar <struct>. Esta opción sólo te la recomendaría si tienes que evitar la opción anterior. Ya que aquí la información queda más "suelta". Para acceder al ingrediente 2 (empezando en 0), haríamos:

Código (c) [Seleccionar] Expandir


char nombre2 = nombre[2];
double precio2 = precio[2];
Parece más sencillo de acceder a cada elemento pero lo tienes guardado en sitios distintos entonces está peor estructurado.

Espero que  esto te sirva para pensar y estructurar bien el programa ya que creo que tienes un lío con las variables. De todas formas espero tu respuesta para ver cómo lo tenías pensado tú, porque puede que no lo hayas implementado bien pero que estuviese bien pensado. Suerte

Primero, un <struct> es muy recomendable definirla fuera de cualquier función ya sea <main> u otra. Por lo tanto te recomiendo que definas la <struct> antes del <main> en vez de dentro.

Además de eso te recomiendo que si estás programando en C++ (lo que parece que es así por <iostream>), uses también las herramientas para tratamiento de archivos que da C++ (librería: <fstream>) y no las herramientas de C que son las que estás usando ahí.

Al margen de eso, pon tu código dentro de etiquetas GeSHi (las puedes seleccionar encima del cuadro de texto cuando escribes/modificas un mensaje), ya que sino se hace más difícil de ver el código. Suerte

Te comento algunos errores que tienes en ese código y después te doy mi punto de vista con los incrementos en la producción. Bueno lo primero, el código ponlo entre etiquetas GeSHi (se seleccionan encima del cuadro de texto) porque sino el código se hace ilegible, puedes comprobarlo tú mismo, que la letra i entre corchetes desaparece.

Te recomiendo que pongas mejores nombres ya que luego para hacer cálculos y para revisar el programa te será más sencillo. Yo usaría algo así:

Código (cpp) [Seleccionar] Expandir


const int MAX_VACAS = 20; // cantidad maxima de vacas (variable global)
const int NUM_VECES = 3; // numero de veces que se toma leche de cada vaca (variable global)
const int NUM_DIETAS = 3; // numero de dietas que se puede aplicar a cada vaca (variable global)
int numero_vacas; // cantidad de vacas que vas a contabilizar
int max_posicion; // posicion de la vaca que mas produce
double max_produccion; // cantidad producida por la vaca que mas produce
double suma_leche, promedio_leche; // total producido y promedio por vaca
int produccion_media, produccion_alta; // contador de producciones altas y medias
double leche_vacas[MAX_VACAS] = {0}; // array para guardar la produccion de cada vaca
double veces[NUM_VECES] = {0, 0.15, 0.3}; // array con los incrementos de cada vez que tomamos leche
double dieta[NUM_DIETAS] = {0, 0.1, 0.2}; // array con los incrementos segun la dieta de cada vaca
Con estas variables puedes hacer todo el programa, pero algunas de estas tienes que declararlas globales (antes del <main>); otras, en el <main> y otras es mejor que las declares dentro de una función especifica (en el último punto especifico esto).

Código (cpp) [Seleccionar] Expandir


cout<<"Ingrese el numero de vacas: "<<endl;
cin>>vacas;
while (vacas<=0){
    cout<<"Error ingrese otro numero: "<<endl;
    cin>>vacas;
}
Primero tienes este trozo de código. Ese <while> es un filtro de toda la vida. Los filtros se suelen hacer con <do while>:

Código (cpp) [Seleccionar] Expandir


const int MAX_VACAS = 20;
double leche_vaca[MAX_VACAS] = {0};
do{
    cout << "Ingrese el numero de vacas (1," << MAX_VACAS << "): "<<endl;
    cin >> numero_vacas;
}  while(numero_vacas <= 0 || numero_vacas > MAX_VACAS);
Ahí tienes lo mismo, pero creo que se ve mejor. Además si tienes un vector estático, controla que no se introducen más vacas que el máximo (que lo puedes controlar con esa constante MAX_VACAS). A partir de aquí usas la variable <numero_vacas> para recorrer el array, ya que si vas a introducir 5 vacas, no tiene sentido recorrer el array entero que son 20 (eso ya lo haces con la variable <vacas>).

En C/C++ los arrays empiezan en el elemento 0. Por lo que los <for> que estás usando en las funciones que inicializas la i siempre a 1, es más correcto hacerlo a 0 (y si quieres que salga un 1 por pantalla pues muestras (i+1) en vez de i). Además en la función <ubicacion()> tienes que empezar a contar en el elemento 0. Tal y como lo estás haciendo te estás saliendo siempre del array y estás accediendo a memoria que puede estar reservada para otra cosa. Eso tienes que corregirlo (no es opcional).

La función <ubicacion()> es más correcto que devuelva la posición del máximo (que para algo se llama <ubicacion()>) y si quieres por referencia puedes guardar el valor de ese máximo. Sino pues haces que se llame <produccionMaxima()> y haces que devuelva la producción máxima y por referencia guardas la posición si quieres. Es más fácil de ver para el resto de personas.

Los valores que calculas en la última función es mejor guardarlos en variables sin mostrar nada y mostrarlo en el programa principal (imagina que en un punto del programa quieres calcular el promedio porque lo necesitas pero no quieres mostrarlo); pues lo calculas con la función y luego ya lo usas como tú quieras o lo muestras o lo usas para hacer más cálculos sin mostrarlo.

El tema de los porcentajes, no sé si tienes que hacerlo aleatoriamente o no. Lo que yo entiendo es que por cada vaca tienes que pedir <NUM_VECES> valores de leche tomada y cada valor se multiplica por (1+veces[m]+dieta[n]). Yo entiendo algo así:

Código (cpp) [Seleccionar] Expandir


double calcularSuma(double leche_vacas, int numero_vacas){
    // aqui creamos los arrays veces y dietas ya que no se usan mas veces en el main
    double toma_actual, suma = 0;
    for(int i = 0; i < numero_vacas; i++){
        for(int j = 0; j < NUM_VECES; j++){
            // puedes hacer el filtro para asegurar cantidades de leche validas
            cout << "Leche tomada de la vaca " << i+1 << "(" << j+1 << "/" << NUM_VECES << "): ";
            cin >> toma_actual;
            leche_vacas[i] += toma_actual * (1+veces[j]+dieta[j]); // dieta[j] u otro valor aleatorio o no
        }
        // haces la suma de cada vaca
    }
    return suma;
}
Algo así entiendo yo. Faltaría terminar esa función (aunque te la he dejado mascada ya...) y adaptarla al resto del programa ya que habría que cambiar más cosas para que quede bien adaptado. Suerte

Si vas a preguntar sobre algo que no está directamente relacionado con este tema, debes abrir un tema nuevo para tu problema. Además de eso te aconsejo que pongas el código que tengas hecho para ver cómo lo llevas (ponlo entre etiquetas de código GeSHi, si lo pones...  )

El problema que tienes es que confundes una variable de tipo char con un literal de tipo char.

Código (c) [Seleccionar] Expandir


char a = 'e';
printf("%c", a); // muestra: e
printf("%c", 'a'); // muestra: a
Si usas un carácter entre comillas simples, estás usando ese caracter literalmente. Y si usas un caracter sin comillas estás usando el nombre de una variable y esa variable puede tener otro caracter guardado.

En tu función si usas 'I', estás usando el caracter 'I', pero si usas I (sin comillas), estás usando el caracter que tenga guardado la variable I que puede ser cualquier letra. Suerte

Una cadena de caracteres de tipo C, es decir, una variable char*, acaba cuando encuentra el caracter '\0'. Por ejemplo:

Código (c) [Seleccionar] Expandir


char *palabra = "hola"; // internamente se ha guardado hola\0
Si creas una cadena ingresando caracteres como en ese bucle, tienes que ingresar al final el caracter de final de cadena '\0'. Los métodos de copia <strcpy()> <strncpy()> y de entrada <gets()> <fgets()> etc ya hacen ellos eso y no tienes que preocuparte de ello. Sólo tienes que hacerlo si ingresas los caracteres "manualmente".

La siguiente línea es simplemente para mostrar la variable por pantalla. Y la última línea es para hacer una pausa y que no se cierre la pantalla del terminal cuando ejecutas el programa. El <system("pause")> es una mala práctica que se recomienda sustituir por <getchar()> en C (incluido en <stdio.h>) y <cin.get()> en C++ (incluido en <iostream>).

Por favor no se enojen conmigo, tengo una duda que a estas alturas va a ser estupida, pero cuando se retorna un 1 o un 0, dependiendo de si el usuario digita un negativo o un positivo, como te se da cuenta que el numero  es positivo o negativo?¿, no seria mejor que al evaluar la condición dentro del if, cuando chequea que es postivo avise mediante un printf que lo que se ingreso es postivo?, tenganme paciencia pliss

En programación, cuando hay dos posibles respuestas (si/no, verdadero/falso, etc) se traduce a una variable booleana (true/false). Las variables booleanas a veces se interpretan mejor como números (true = 1 / false = 0) y esto sirve para tener un abanico más grande de posibilidades para trabajar por ejemplo con condicionales.

El tema de retornar un 0/1 y no usar un <printf()> es por sencillez. Imagina un programa en el que usas esas funciones que has creado:

Código (c) [Seleccionar] Expandir


int main(){
    // codigo
    if(positivo(n)){
        // codigo
    }
    // codigo
}
Tú necesitas saber si <n> es positivo, pero no hace falta que le avises al usuario. Puede que tengas un programa muy grande donde haces miles de comprobaciones, el usuario no necesita ver cual es el resultado de cada comprobación.

Con el código que te mostré anteriormente puedes aprovechar lo que te he comentado de interpretar 1 = true y 0 = false para usar esas funciones en programas más grandes. Los posibles casos serían:
- n >= 0 -> positivo(n) retorna 1 (true) y negativo(n) retorna 0 (false)
- n < 0 -> positivo(n) retorna 0 (false) y negativo(n) retorna 1 (true)
Por eso por ejemplo en cada función se llama a la otra con el operador de negación(!). Para que los resultados que se obtienen con cada función sean los comentados arriba. Te dejo el código aquí por si quieres comprobarlo:

Código (c) [Seleccionar] Expandir


int positivo(int n){
    if(n >= 0)
        return 1;
    else
        return !negativo(n);
}

int negativo(int n){
    if(n < 0)
        return 1;
    else
        return !positivo(n);
}