• Las variables es recomendable declararlas locales, dentro de la función main().
• Este es el escenario típico para usar un for() en vez de un while(). Además es mejor usar las funciones length() o size() antes que sizeof().

for(int i = 0; i < cadena.length(); ++i) {
 //...
} 

• No es recomendable usar system("pause"). Utiliza cin.get() en su lugar.
• Puedes acortar las asignaciones.

// Las dos lineas obtienen el mismo resultado. Esto se puede hacer con otros operadores y otros tipos de variables
numeros = numeros + loquesea;
numeros += loquesea;

• Todos los (i == args) del for() no se van a cumplir nunca. El bucle no se va a repetir nunca con i = args, el último valor de i dentro del bucle será args-1 porque cuando i sea igual a args, la condición del for() no será true y no llegará a entrar en su interior.
• El <case 2> del <switch> tiene otro error. Si pones "f" o "d" te dará un error porque una de las dos comprobaciones no se va a cumplir, mientras que si pones cualquier otro carácter te dará 2 errores seguidos. Tienes que cambiar eso.
• Estás haciendo las asignaciones de cadenas con el operador =. En este caso no estás aprovechando la reserva de memoria que haces pues no estás copiando el contenido de una cadena en otra. Tan solo estás haciendo que el puntero que tú has creado apunte al comienzo de la cadena original. Para copiar el contenido debes usar la función strncpy() y es entonces cuando tienes que reservar memoria.

• Por un lado un identificador de esa variable. Un valor que representa unívocamente la variable -> Su dirección de memoria. No puede variar durante la ejecución.
• Por otro lado el contenido almacenado en ese espacio. El valor que se guarda en esa variable. Puede variar durante la ejecución.

• Puntero: Variable que su contenido es siempre una dirección de memoria. Al ser así los punteros tienen 2 direcciones de memoria: una de ellas es su identificador y la otra es su contenido.
• Operador * (asterisco): Desreferencia un puntero. Hace que el puntero no devuelva la dirección de memoria que tiene almacenada en su contenido sino que devuelve el contenido de esa dirección de memoria. Excepción: En la línea en que se define el puntero, el operador * no desreferencia, sólo indica que se está declarando un puntero.
  
  Código:

  Suponemos que la posición de memoria 0x1234 contiene el valor 8
  Puntero p = 0x1234 -> Un puntero siempre contiene direcciones de memoria
  Mostrar p -> Muestra (el contenido de p): 0x1234
  Mostrar *p -> Muestra (el contenido de la dirección de memoria 0x1234): 8 

• Operador & (ampersand): Se puede aplicar a cualquier variable. Obtiene la dirección de memoria de esa variable (su identificador único e invariable) en vez de su contenido.
  
  
  Código

  int main() {
    int a = 5; // El programa reserva la posicion 0x1 de la memoria (para a) y guarda en su interior el valor 1. Lo representare a partir de ahora como -> 0x1(5)
   
    int *p = &a; // El programa reserva la posicion 0x2 de la memoria (para p) y guarda en su interior la direccion de memoria de a (0x1) -> 0x2(0x1)
   
    cout << "El valor de a es: " << a << " y su direccion de memoria es: " << &a << endl; // Muestra: "El valor de a es: 5 y su direccion de memoria es: 0x1"
    cout << "El valor de p es: " << p << " y su direccion de memoria es: " << &p << endl; // Muestra: "El valor de p es: 0x1 y su direccion de memoria es: 0x2"
    cout << "Desreferenciamos p: " << *p << endl; // Muestra: "Desreferenciamos p: 5"
   
    // Ahora vamos a probar a cambiar valores a ver que pasa
    int b = 8; // El programa reserva la posicion 0x3 de la memoria (para b) y guarda en su interior el valor 8 -> 0x3(8)
    *p = b; // Que pasa aqui? No se cambia la direccion de memoria que contiene p (0x1). Se cambia el valor que hay dentro de 0x1 (5). 0x1 es la direccion de memoria que identifica a la variable a -> 0x1(8)
    cout << "El valor de a es: " << a << " y su direccion de memoria es: " << &a << endl; // Muestra: "El valor de a es: 8 y su direccion de memoria es: 0x1"
    // Hemos cambiado el contenido de a (5 -> 8) pero su direccion de memoria no varia, sigue siendo 0x1
    cout << "El valor de p es: " << p << " y su direccion de memoria es: " << &p << endl; // Muestra: "El valor de p es: 0x1 y su direccion de memoria es: 0x2" -> Como vemos esto no ha cambiado nada
    cout << "Desreferenciamos p: " << *p << endl; // Muestra: "Desreferenciamos p: 8" -> Esto si ha cambiado porque el contenido de 0x1 ahora es 8, no 5
   
    // Hasta aqui todo bien supongo. Asequible, pero... y ahora que?
    int **pp = &p; // El programa reserva la posicion 0x4 de la memoria (para pp) y guarda en su interior la direccion de memoria de p (0x2) -> 0x4(0x2)
    // Al usar ** estamos declarando un puntero a puntero. Un puntero que guarda como valor la direccion de memoria de otro puntero
    // Ahora vamos a comprobar que se sigue cumpliendo lo que decimos:
    cout << "El valor de pp es: " << pp << " y su direccion de memoria es: " << &pp << endl; // Muestra: "El valor de pp es: 0x2 y su direccion de memoria es: 0x4"
    cout << "Desreferenciamos pp: " << *pp << endl; // Muestra: "Desreferenciamos pp: 0x1"
    // Aclaremos la linea anterior: Al desreferenciar un puntero no mostramos la direccion de memoria que contiene sino el contenido de esa direccion de memoria
    // pp contiene 0x2 -> Al desreferenciar obtenemos el valor que se guarda dentro de la direccion 0x2 y si vamos a la linea de p vemos que el valor que guarda la direccion 0x2 es: 0x1  &#8203;
   
    // Ahora entonces como *p devuelve una direccion de memoria (un puntero), podemos ver que contiene esa direccion de memoria (podemos desferenciarlo de nuevo):
    cout << "Desreferenciamos *pp: " << **pp << endl; // Muestra: "Desreferenciamos *pp: 8" -> Si *pp devuelve 0x1, el contenido de la direccion 0x1 es: 8
  } 

  
  Se acabó el programa y la tabla de direcciones de memoria y contenido es:
  
  Código:

  Variable a -> Direccion de memoria: 0x1 -> Contenido: 8
  Variable p -> Direccion de memoria: 0x2 -> Contenido: 0x1
  Variable b -> Direccion de memoria: 0x3 -> Contenido: 8
  Variable pp -> Direccion de memoria: 0x4 -> Contenido: 0x2 

  ---

  RESUMEN
  -------------------
  - Todas las variables están formadas por una dirección de memoria y un contenido.
  - Las direcciones de memoria de cada variable las asigna el sistema operativo y no se pueden modificar.
  - El contenido de las variables puede ser un valor o una dirección de memoria (en el caso de los punteros). El contenido lo asignamos nosotros y se puede modificar.
  
  
  PD: Se me ha podido pasar algún error en el código. De ser así no dudéis en avisarme para corregirlo pues es un tema en el que la exactitud es muy importante.
  PD2: El código hay que estudiarlo sin prisa, hacer las pruebas que consideréis y preguntar cualquier duda que os pueda quedar.

2 1/1
3 2/2
4 3/3
5 5/5
6 7/7
7 10/1
... 

• Los números {1, 2, 3, 5 y 7} no son considerados números omirp porque son capicúa (sus palíndromos son ellos mismos).
• El 10 no es primo (y realmente el 1 tampoco)

int a = 3;
int b = 2;
printf("Resultado %d/%d = %d", a, b, a/b); // Resultado 3/2 = 1 

int a = 3;
int b = 2;
printf("Resultado %d/%d = %.1f", a, b, (float)a/b); // Resultado 3/2 = 1.5 

• Las funciones no siguen las normas básicas de las funciones:
  Una función debe realizar una función completa y autónoma. Una función es un fragmento de código que puedes reutilizar muchas veces. Para ello tiene que hacer una tarea muy bien definida y genérica. Por ejemplo: calcularMedia(...), mostrarMatriz(...), buscarMaximo(...), ... Si te fijas es muy sencillo saber qué hacen esas funciones, en cambio dos funciones que se llaman lista_de_personas_M() y lista_de_personas_F() no se sabe qué hacen a simple vista. Y además no hacen una tarea concreta sino que tienen dentro todo el programa en sí.
  
  
• El nombre del struct no es del todo preciso. La estructura define una persona, no una lista de personas. Además estás definiendo en la línea 20 un array de struct global (no recomendable). Y cada vez que quieras usar el struct debes poner la palabra struct: en la línea 25 te falta el nombre de la variable. Poner: 'struct lista_de_personas;' es como poner: 'int;' Falta el nombre de la variable, sólo estás indicando el tipo que va a tener pero no cómo se llama. Seguramente este sea el primer error que te da al compilar.
  Otra cosa importante es que estás usando un char para guardar el nombre y otro para el apellido. Es decir, un único carácter para cada cosa, no una cadena.
  
  Una recomendación es usar 'typedef' para no tener que usar la palabra 'struct' todo el tiempo.
  

// Consejo EXTRA: Utiliza constantes para la longitud de los arrays estaticos
#define MAX_LONGITUD_NOMBRE 20
#define MAX_LONGITUD_APELLIDO 50
 
typedef struct {
  char nombre[MAX_LONGITUD_NOMBRE];
  char apellido[MAX_LONGITUD_APELLIDO];
  // El DNI lo guardaria como un char[] y no como un int
  //...
} Encuestado;
 
int main() {
  // Ahora para declarar un array de encuestados no hace falta hacer:
  struct Encuestado encuestados[];
  // Tan solo tienes que hacer:
  Encuestado encuestados[];
} 

• El main() de un programa de este estilo debería dar una visión general de lo que hace el programa (no cómo lo hace pero sí qué hace). En este caso si lees el main() te quedas más o menos así: 
  Yo apostaría por algo más de este estilo:

#define NUM_ENCUESTADOS 10
#define NUM_CANCIONES 5
//...
 
int main() {
  Encuestado encuestados[NUM_ENCUESTADOS];
 
  for(int i = 0; i < NUM_ENCUESTADOS; ++i) {
    printf("Introduce el nombre del encuestado %d: ", (i+1));
    // Consejo EXTRA: Las cadenas de texto se leen con fgets() no con scanf(). Volveremos a esto mas adelante
    fgets(personas[i].nombre, MAX_LONGITUD_NOMBRE, stdin);
 
    printf("Introduce la edad del encuestado %d: ", (i+1));
    scanf("%d", &personas[i].edad);
 
    //...
  }
  // Tambien puedes hacer una funcion que sea pedirDatosEncuestado(Encuestado encuestado) y dentro poner todos los mensajes pidiendo datos y guardando la entrada del teclado...
 
  // Aqui ya puedes usar las funciones que quieras en base a lo que necesites
  for(int i = 0; i < NUM_ENCUESTADOS; ++i) {
    printf("***** DATOS DEL ENCUESTADO %d *****\n", (i+1));
    // En el main() no necesito saber como va a mostrar los datos pero se lo que va a hacer. Para los detalles siempre puedes mirar dentro de la funcion
    mostrarDatosEncuestado(encuestados[i]);
    printf("\n");
  }
} 

• Entrada de datos: La función fflush() no debe usarse para limpiar el buffer de entrada (stdin). El fin de esta función (mal utilizada) es eliminar los saltos de línea '\n' que se insertan en el buffer de entrada al pulsar Enter. Aquí pueden darse 2 casos:
  
  • Lectura de cadenas de caracteres. La forma correcta/segura es mediante la función fgets(). Aquí pueden darse 2 casos también:
    
    • Se introducen más caracteres de los que se pueden almacenar en el array -> En el buffer quedarán todos los caracteres que no caben en el array y al final el salto de línea '\n'. Todo esto que queda en el buffer tiene que limpiarse.
      
    • Se introducen menos caracteres de los que se pueden almacenar en el array -> Se guardan todos los caracteres (incluido el salto de línea) y el buffer queda vacío.
      
    Para ambos casos se puede usar el siguiente código:
  Código

  char cadena[MAX_SIZE]; // La longitud maxima es indiferente
  printf("Introduce una cadena: ");
  fgets(cadena, MAX_SIZE, stdin);
  if(cadena[strlen(cadena) - 1] == '\n') // Si el ultimo caracter guardado es el salto de linea -> El buffer esta limpio
    cadena[strlen(cadena) - 1] = '\0'; // Eliminamos el salto de linea que es muy molesto
  else // En caso de que el ultimo caracter no sea un salto de linea, significa que quedan restos en el buffer de entrada -> Hay que limpiar todo
    while(getchar() != '\n'); // Elimina los caracteres que quedan en el buffer hasta encontrar el salto de linea (que es el ultimo caracter del buffer) 

  • Lectura de datos que no sean cadenas de caracteres. Para este caso la función más común a utilizar es scanf(). Esta función nunca incluye el salto de línea dentro de la variable por lo que siempre quedará en el buffer. En este caso tan solo hay que limpiar todo el buffer justo después de un scanf() para asegurarnos de que siempre estará limpio.
  Código

  printf("Introduce un numero: ");
  scanf("%d", &numero);
  while(getchar() != '\n'); // Con el bucle podremos limpiar cualquier resto si se introduce un dato no valido ademas del salto de linea