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í:

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).

---

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>:

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í:

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.

 
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:

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>).

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:

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:

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);
} 

Cuando no puedas usar variables globales o aunque puedas si prefieres no usarlas ya que no es recomendable porque el código pierde seguridad, todo lo que no puedes usar en una función porque no es global, se lo pasas como parámetros. Además los vectores cuando no se usa todavía memoria dinámica se suelen crear usando una constante para el tamaño, así si luego se quiere cambiar el tamaño, basta con cambiar el valor de esa constante.

Te pongo un ejemplo bastante completo que tiene cómo pasar arrays como parámetros, cómo usar constantes y qué hacer si no vamos a usar el array entero.

#include <stdio.h>
 
const int TAM = 100;
 
void mostrarVector(int[], int);
 
int main(){
    int vector[TAM];
    int util = 10; // se podria preguntar al usuario cuantos valores quiere ingresar
    for(int i = 0; i < util; i++){
        printf("Elemento %d: ", i);
        scanf("%d", &vector[i]);
    }
    printf("\nEl contenido del array es: ");
    mostrarVector(vector, util);
}
 
void mostrarVector(int v[], int size){
    for(int i = 0; i < size; i++)
        printf("%d  ", v[i]);
    printf("\n");
} 

Ahora aprovecha las cosas que aparecen en este ejemplo para adaptarlo a tu código. Suerte

PD: No utilices la librería <conio.h>, no es estándar.

Aunque ya tengas el tema solucionado, lo importante es resolver las dudas que quedan así que...
- <sizeof()> se usa para obtener el número de bytes que ocupa un tipo de dato. En ese código te devuelve el número de bytes que ocupa un <unsigned long long>.
- <--s> significa decrementar <s> en 1. Al igual que se suele hacer <i++>, se puede hacer también <i-->, <++i> o <--i>. A veces da igual usar el prefijo o el sufijo (cuando es una sentencia aislada, que no va como "encadenada"). El prefijo primero hace el incremento/decremento y después el resto de la sentencia; el sufijo primero hace el resto de la sentencia y al final hace el incremento/decremento.

for(int i = 0; i < 5; i++) // aqui da igual i++ o ++i porque esta solo
    printf("%d", i++); // primero muestra i y luego lo incrementa en 1. Salida: 0, 2, 4
 
for(int i = 0; i < 5; i++)
    printf("%d", ++i); // incrementa i y luego lo muestra. Salida: 1, 3, 5 (el 5 se muestra aunque la condicion es i < 5) 

---

Si haces <num >> 1> lo que haces es mover los bits de <num> una posición a la derecha. Si tienes:
a = 01011001
a >> 1
a = 00101100
Si el número es negativo se extiende con unos:
a = 11010011
a >> 1
a = 11101001

Como dato interesante que si no te paras a estudiar los bits no te das cuenta es que mover una posición a la izquierda un número en binario es equivalente a multiplicar ese número por 2. Y entonces moverlo una posición a la derecha es equivalente a dividirlo por 2, aunque si es impar se hará obviando los decimales.

---

Entonces para que entiendas el código ese que la verdad aunque poco efectivo, me parece impresionante:
Usa una función donde manda un <unsigned long long> que es el número a calcular y le pasa como segundo parámetro el número de bits que ocupa un número <unsigned long long> (con <sizeof()> saca el número de bytes y eso por 8, en bits).
Entonces cuando <s == 1> es decir, cuando sólo quede el bit más significativo se retorna ese bit (que valdrá 1 si el número es negativo o 0 si no lo es). Y si <s != 1>, mueve todos los bits una posición a la derecha y decrementa el número de bits que quedan todavía. Algo así en un caso simplificado:
n = 4 (0100) s = 4
s == 1? No -> n = 2 (0010) s = 3
s == 1? No -> n = 1 (0001) s = 2
s == 1? No -> n = 0 (0000) s = 1
s == 1? Si -> return n (return 0)

---

n = -2 (1110) s = 4
s == 1? No -> n = -1 (1111) s = 3 // los negativos se extienden con 1 para que sigan siendo negativos (cosas del complemento a 2)
s == 1? No -> n = -1 (1111) s = 2
s == 1? No -> n = -1 (1111) s = 1
s == 1? Si -> return n (return 1)

---

Una función de ese estilo es mejor que no muestre nada por pantalla por si quieres usar esa función dentro de un condicional, sería más funcional entonces sin los <printf()>:

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);
} 

Espero que esto te ayude a entender y profundizar más en todo lo que se puede hacer con la programación. Suerte

No entiendo muy bien tu duda, pero si quieres pasar un array n-dimensional a una o más funciones claro que puedes hacerlo. Simplemente tienes que pasar en otro/s parámetro/s su tamaño para poder recorrerlo.
Si no he resuelto tu duda y me puedes explicar un poco mejor a que te refieres, intentaré ayudarte. Suerte 

Si pudieras especificar un poco más tu problema... Es decir, ese programa compilar, compila (si le añades la librería <stdio.h> para poder usar <scanf()> y <printf()>). Además puedes quitar <stdlib.h> y <string.h> ya que no estás usándolo para nada en todo el programa.

De todos modos ese programa sigue teniendo errores (aunque ya compila). Si llamas a <positivo(n)> con n positivo, sale el mensaje por pantalla "el numero ingresado es positivo" pero no has hecho ningún <return> (creo que entonces se retorna n pero es mejor especificarlo en el código para que quede explícito).

Si llamas a <negativo(n)> con n negativo, la función retorna n, pero no se mostrará por pantalla "el numero ingresado es nevativo" (creo que querías poner "neGativo" ) porque una vez que una función ejecuta un <return> ya sale de la función y no se ejecuta lo que venga después.

Por eso que no se muy bien cual es el fin de esa función, si quieres retornar el mismo número que mandas como parámetro o quieres retornar 1 o 0 como si fuese true o false respectivamente... Y sí, si quieres crear otra función que llame a una de esas puedes hacerlo, pero lo veo un poco absurdo todo esto porque son dos funciones muy sencillas. Algo más funcional sería:

int positivo(int n){
    return (n >= 0);
} 

Que devuelve 1 si es positivo y 0 si es negativo. De que sirve crear una función <negativo()> si <negativo() == !positivo()>??