#include <iostream> // La cabecera de entrada/salida estandar de C++ es <iostream>, no <iostream.h>
using namespace std;
 
const int NUM_MESES = 12; // Longitud del array con los dias de cada mes (12 meses)
 
int calcularDiasAnuales(int dia, int mes) {
  // El indice i indica el numero de dias del mes (i+1) => i = 0 -> dias del mes 1 (enero) -> diasMes[0] = 31
  int diasMes[NUM_MESES] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 
  int diasAnuales = 0; // Se puede inicializar aqui con: 'diasAnuales = dia' pero asi es mas visual
  for(int i = 0; i < mes - 1; ++i)
    diasAnuales += diasMes[i];
 
  diasAnuales += dia;
  return diasAnuales;
}
 
 
int main() {
  int diasMes[NUM_MESES] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 
  int dia = 22;
  int mes = 3; // Marzo
 
  int diaAnual = calcularDiaAnual(dia, mes);
  cout << "El dia " << dia << "/" << mes << " es el dia " << diaAnual << " contando desde el 01/01" << endl;
} 

• Como he dicho en el código: La cabecera correcta es <iostream>, no <iostream.h>
• No utilices la función getche() de <conio.h>. Esta librería no es estándar y es preferible no usarla nunca. Utiliza la función cin.get() que pertenece a <iostream>.
• No estás utilizando la cabecera <math.h> (ni la vas a necesitar).
• Las condiciones que estás utilizando no existen. Tienes que utilizar las variables 'd' y 'm' (que deberías llamar 'dia' y 'mes' para tener nombres más claros)
• Las variables 'd' y 'm' deberías declararlas dentro del main() como variables locales, no fuera como variables globales.

• La función main() debe ser de tipo int.
  Aunque en ciertas fuentes antiguas puede aparecer la función main() de tipo void. Lo correcto es que sea de tipo int.
  Además es la única función que no necesitas indicar expresamente al final el 'return 0' ya que el compilador lo agregará automáticamente si no lo haces tú.
• Las variables y funciones se escriben con minúsculas.
  La nomenglatura camelCase (ej: numAlumnos, calcularPromedio()) está aceptada tanto para variables como funciones.
  La nomenglatura snake_case (ej: num_alumnos) está mayormente aceptada para variables que para funciones.
  La nomenglatura SCREAMING_SNAKE_CASE (ej: NUM_ALUMNOS) está única y exclusivamente aceptada para constantes.
  La nomenglatura PascalCase (ej: NumAlumnos) se utiliza para structs.
• Utiliza funciones bien definidas y nómbralas con nombres que permitan identificar su funcionalidad.
  Qué será mejor? Tener una función que se llame como la primera o como la segunda:

// PRIMERA OPCION
float calcularPromedio(float matriz[][NUM_NOTAS], int numAlumnos, int alumno);
// USO
for(int i = 0; i < numAlumnos; ++i) {
  printf("El promedio del alumno %d es: %.2f", i+1, calcularPromedio(matriz, numAlumnos, i));
}
 
// SEGUNDA OPCION
float funcion1(float A[][EXA], int T); 
// USO
// ??? Pues no se como usarla porque no se que parametros tengo que pasarle ya que no son descriptivos 

int num_filas;
printf("Introduce la cantidad de filas: ");
scanf("%d", &num_filas); 
 
printf("La cantidad de filas es: %d", num_filas); 

//codigo1
cout<<"edad: "<<(punteroemp+pos)->edad<<endl;
 

//codigo2
cout<<*(*(matriz+i)+j)<<" ";
 

struct Empleado {
  int* edad;
};
 
int main() {
  Empleado *puntero_empleado = new Empleado; // Reservamos memoria para el puntero a 'Empleado' -> No relevante ahora mismo
 
  // 'puntero_empleado->edad' es equivalente a: '(*puntero_empleado).edad'
  // La primera sintaxis es mas elegante y mas facil de leer pero significa exactamente lo mismo
  puntero_empleado->edad = new int; // Reservamos memoria para poder guardar un int (ahora es necesario porque edad es un puntero) -> No relevante ahora mismo
  puntero_empleado->edad = 5; // ERROR!! Estas asignando un int (5) a un puntero
  *(puntero_empleado->edad) = 5; // CORRECTO!!
  *(*(puntero_empleado).edad) = 5; // Esto tambien es correcto pero se lee peor
 
  cout << puntero_empleado->edad << endl; // Esto te mostrara la direccion de memoria del puntero 'edad'
  cout << *(puntero_empleado->edad) << endl; // Esto te mostrara el contenido de la direccion de memoria del puntero 'edad': 5
 
  // Si reservamos memoria dinamica mediante 'new', al dejar de usarla hay que liberarla con 'delete' -> No relevante ahora mismo
  delete(puntero_empleado->edad);
  delete(puntero_empleado);
} 

• Operador * -> Sólo se puede usar con punteros: Devuelve el contenido que está almacenado en la dirección de memoria a la que apunta el puntero.
  
• Operador & -> Se puede usar con cualquier tipo de variable: Devuelve la dirección de memoria de esa variable.
  
  
  Código

  int var = 5; // Variable "normal"
   
  // NOTA: Cuando se asigna un valor (direccion de memoria) a un puntero al mismo tiempo que se declara estamos ante una situacion especial
  // Aunque estemos usando el asterisco realmente no estamos accediendo al contenido al que apunta, en este momento el asterisco solo significa que hemos declarado un puntero
  int *p_var = &var; // Puntero a int
  // La linea anterior es equivalente a:
  // int *p_var;
  // p_var = &var;
   
  cout << var << endl; // Muestra el contenido de var: 5
  cout << &var << endl; // Muestra la direccion de memoria donde se esta guardando 'var'. Imaginemos que es: 0x1 (realmente sera un numero mas largo)
   
  // Ahora estamos accediendo al contenido del puntero p_var -> ¿Que guarda un puntero? Una direccion de memoria, en este caso la de 'var'
  cout << p_var << endl; // Muestra: 0x1
  cout << *p_var << endl; // Muestra el contenido guardado en la direccion de memoria guardada en 'p_var' -> p_var = 0x1 -> Contenido en 0x1: 5
  cout << &p_var << endl; // Muestra la direccion de memoria donde se esta almacenando el puntero 'p_var'. Supongamos 0x5 (realmente sera otro numero largo)
   
  // Ahora complicamos mas la situacion:
  int **pp_var; // Doble puntero -> Significa que tiene que guardar una direccion de memoria pero no una cualquiera. Tiene que guardar la direccion de memoria de un puntero
  pp_var = &p_var; // Aqui tenemos la direccion de memoria de un puntero (0x5), nos sirve.
   
  // Y ahora llega lo divertido. Te reto a entender que se esta mostrando en cada momento y si lo consigues, ya tendras los punteros mucho mas dominados de lo que pensabas:
  cout << pp_var << endl;
  cout << &pp_var << endl;
  cout << *pp_var << endl;
  cout << **pp_var << endl;
   

  
  Puedes hacer un programa con el código anterior y ejecutarlo para verlo con valores de verdad.
  Verás que aunque las direcciones de memoria son más largas, se cumple que el valor real de lo que yo he llamado 0x1 en la línea 11 es el mismo que en la línea 14. Y así con 0x5 también.
  
  PD: Soluciones:
  
  Código

  cout << pp_var << endl; // Muestras lo que esta guardando el puntero doble 'pp_var' -> Guarda la direccion de memoria de 'p_var' -> 0x5
  cout << &pp_var << endl; // Muestra la direccion de memoria propia de 'pp_var' -> Sera otra diferente: 0x15 por ejemplo
  cout << *pp_var << endl; // Muestra el contenido de 'p_var' -> 'p_var' contiene la direccion de memoria de 'var' -> 0x1
  cout << **pp_var << endl; // Muestra el contenido del contenido de 'p_var' -> 'p_var' contiene la direccion de memoria de 'var' (0x1) -> Esta direccion contiene el valor de 'var' -> 5

void setup()

int findAlphabeticIndex(char character) {
  int index = -1;
  char alphabet[] = "abcd...";
  char lower_character = tolower(character);
  for(int i = 0; i < strlen(alphabet) && index == -1; ++i)
    if(lower_character == alphabet[i]) index = i + 1;
  return index;
} 

int findAlphabeticIndex(char character) {
  char lower_character = (character >= 'A' && character <= 'Z') ? character + ('a' - 'A') : character;
  return (lower_character >= 'a' && lower_character <= 'z') ? lower_character - 'a' + 1 : -1;
} 

fgets(cadena, 200, stdin); 

lista = [] // la lista esta vacia

linea = [_, _, _, _, _] // linea apunta a la direccion de memoria 0x1 (por ejemplo) 

linea = [H, o, l, a, \0] // Podemos obviar el \0 

lista = [linea]
// Esto realmente es lo mismo que:
lista = [0x1] // Guardamos la dirección a la que esta apuntando el puntero 'linea'

linea = [M, u, n, d, \0] // UPS! No cabe (no importa porque fgets() lo soluciona solito) 

lista = [linea, linea]
// O lo que es lo mismo (seguro que ya has visto el problema):
lista = [0x1, 0x1]

Elemento 0 -> Vamos a 0x1 y tenemos: [M, u, n, d, \0]
Elemento 1 -> Vamos a 0x1 y tenemos: [M, u, n, d, \0] 

MIENTRAS !fin(fichero) HACER
  linea = leerLinea(fichero)
  lista.agregar(new char[SIZE])
  copiar(linea, lista[ultimoElemento])
FIN MIENTRAS 

• Estás utilizando C++, por lo que puedes aprovechar el tipo string para facilitarte el trabajo con los char*.
• Utiliza una constante para el tamaño del array y en el fgets() aprovecha el mismo tamaño. Para qué sino reservar un array de tamaño 100 si luego sólo vas a copiar como máximo 50 caracteres??

const int LINE_SIZE = 100;
 
int main() {
  char* linea[LINE_SIZE]; // Puede ser estatico (mas sencillo)
  //...
  fgets(linea, LINE_SIZE, file);
  char *nuevo_puntero = new char[strlen(linea) + 1]; // Puedes ahorrar espacio creando los arrays con la longitud justa necesaria
  strcpy(nuevo_puntero, linea);
  // Ahora ya puedes modificar 'linea' todo lo que quieras que no afectara a nuevo_puntero
}