Mensajes

Como dice @Eternal Idol, no debería haber ninguna diferencia.
Sólo decir que en el código anterior faltan unas comillas dobles antes del % pero supongo que ha sido un error al escribir el mensaje pues sino no compilaría el programa.

Qué más haces con esa variable?
Pega un par de ejecuciones donde se vea funcionando bien y fallando para poder echarle un ojo...

[no se hacen tareas]

Para obtener las diferentes cifras de un número tan solo necesitas usar los operadores de disivión (/) y de módulo (%) junto con tu mayor aliado: el número 10.

Si quieres más ayuda, expón tu código pues no se hacen tareas.

Gracias. Deduzco entonces que IOSTREAM incluye a LOCATIONS, pues me sucedió lo mismo que con CCTYPE en lo referente a ALGORITHM

No se debe suponer que una cabecera incluirá otras pues esto depende de cada implementación, de cada compilador.
Lo que a ti te funciona sin declarar una cabecera, a otra persona le puede fallar. Lo mejor es que si sabes que necesitas usar una cabecera, la declares explícitamente.

Lee los errores que te aparecen pues te dicen bien claro cuáles son los problemas.
No hay mayor virtud para un programador que entender los errores que lanza el compilador.

Pasar a C no es lo mismo que copiar y pegar mi pseudocódigo. Tal y como dicen los errores, hay variables sin declarar, funciones que no existen (porque no existen) y conflictos en la definición de la función.

Tal y como dices, los ficheros .o son normales. Estos son ficheros intermedios que genera el compilador antes de crear el ejecutable final y se suelen crear en el directorio obj/ de tu proyecto. No se les suele prestar mucha atención cuando se trabaja con IDEs, por eso igual te parecen extraños. Tendrás alguna opción de limpiar proyecto o similar que te los borrará.

Cuándo y dónde te aparece el error que comentas??
Este problema lo tienes desde que empezaste a usar Codeblocks??
Has instalado algo (relacionado con Codeblocks) o cambiado alguna configuración poco antes de que te empezase a aparecer este error??

Fíjate en los comentarios de MOD que tienes en el mensaje anterior. 


Piensa cada uno de los filtros por separado y luego tan solo tienes que juntarlos.
Obviamente tendrás que pasar los parámetros a la función para poder usarlos.

Para filtrar por tipo, lo único que tienes que hacer es comprobar que el tipo. Si el tipo es el que buscas, muestras la ruta y en caso contrario lo ignoras.
Para filtrar por profundidad con recursividad tienes que definir una condición de salida para dejar de aplicar la recursividad. En pseudocódigo sería algo así:

Código [Seleccionar] Expandir


mostrarFiltrado := function(path, type, max_depth, current_depth)
INICIO
  dir := abrirDirectorio(path)
  current_path := obtenerSiguienteElemento(dir)
  MIENTRAS EXISTE current_path HACER
    SI current_path.type == type ENTONCES // Parte del codigo para el filtro por tipo
      MOSTRAR current_path
    FIN SI // Parte del codigo para el filtro por tipo
    SI current_path.type == directorio AND current_depth < max_depth ENTONCES // Parte del codigo para el filtro por profundidad
      mostrarFiltrado(current_path, type, max_depth, current_depth + 1)
    FIN SI // Parte del codigo para el filtro por profundidad
    current_path := obtenerSiguienteElemento(dir)
  FIN MIENTRAS
FIN

PD: Si sabes aprovechar el current_depth para establecer una tabulación al mostrar las rutas, la salida te quedará mucho más profesional.

El programa no tiene nada que ver en esto, es un programa de lo más normal y no influye para nada en otros.
El problema debe de estar en el propio IDE. Alguna configuración que hayas modificado o algo por el estilo.

PD: Ya que está:

• 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().
  
  Código (cpp) [Seleccionar] Expandir
  
for(int i = 0; i < cadena.length(); ++i) {
//...
}
  
• No es recomendable usar system("pause"). Utiliza cin.get() en su lugar.
  
• Puedes acortar las asignaciones.
  
  Código (cpp) [Seleccionar] Expandir
  
// Las dos lineas obtienen el mismo resultado. Esto se puede hacer con otros operadores y otros tipos de variables
numeros = numeros + loquesea;
numeros += loquesea;

Además de lo comentado por @BloodSharp, veo más errores en el código:

• 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.
  
  Comprueba que la función readdir() devuelve un puntero.
  Si después de todo, no se resuelve tu problema, agrega un ejemplo de ejecución para tener más información y no ir a ciegas.
  
  PD: Sobre la duda de la línea 69, está bien. Si fuese argv estarías preguntando por el valor del primer argumento (que es una cadena), no por el índice del argumento.

[global]

sólo en el caso de que defina otra variable global, valiéndome de un mismo puntero // no haciendo falta definir otro // direccionador para ambas variables, obtendré, ahora sí, dos Direcciones de Memoria Física diferentes ( lo constato más aún si a a ambas variables les asigno el mismo Valor )

Sólo aclarar que la variable da igual que sea global que local.

Para entendernos, cuando tú le dices al programa "crea una variable", el programa reserva un espacio para esa variable. Cada variable podríamos decir que tiene 2 partes:

• 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.
  
  Un ejemplo que puede ser un poco más complejo pero que si le das una vuelta y lo entiendes creo que habrás avanzado mucho. PD: Me inventaré las direcciones de memoria por simplificarlas y porque es imposible adivinar qué dirección de memoria se va a asignar a cada variable en cada ejecución. Eso no depende de nosotros.
  
  Antes del ejemplo, varios puntos que hay que tener claros:
  
• 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 [Seleccionar] Expandir
  
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 (cpp) [Seleccionar] Expandir
  
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  ​

  // 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 [Seleccionar] Expandir
  
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.

ya verás con lós numeros  "long long" hazlo siempre en coma flotante convierte lo que no sean y muestra el resultado.



no enfrentes a un entero con un flotante, antes conviértelo (float)

redondear no te hace falta, pasa sólo al pasarlo a entero (int). En esas operaciones han de entrar con los participantes flotantes. (float)x dividido por (float)y es igual a (int)z

Imagino que el tema principal de este hilo está cerrado ya que el usuario que lo empezó no ha vuelto a contestar.
Sin embargo, respecto a este comentario hay cosas no muy claras:

no enfrentes a un entero con un flotante, antes conviértelo (float)

No es necesario, operar un int con un float ya da como resultado un float. Lo importante es guardarlo en una variable de tipo float y no int.

redondear no te hace falta, pasa sólo al pasarlo a entero (int)

Cuando se convierte un float en int no se redondea, se trunca.