Mensajes

También:

Código (cpp) [Seleccionar] Expandir

printf("%02d", 1);

Eso no es c++

Nota inicial: para dar color al código, la etiqueta code tienes que dejarla así (pero sin espacios): [ code = c ]

Código (c) [Seleccionar] Expandir

  x=n;
  y=n-x;
  if(y==0)
  {


Si x = n entonces y = 0, luego siempre va a entrar en el if. Eso no tiene demasiado sentido, no?

Además la asignación x = n te genera otro problema y es que estás usando el mismo valor en dos variables. Quiero decir, luego no modificas ni n ni x, por lo que te puedes ahorrar el uso de una de las dos variables.

Si lo que quieres es limitar la entrada a números enteros, puedes hacerlo así:

Código (c) [Seleccionar] Expandir


int dato;

// leemos un numero entero
fscanf( stdin, "%d", &dato );

// lo convertimos a float
float n = (float)dato;

Mas cosillas, lo del uso de fmod no lo he terminado de entender. Me explico:

Código (c) [Seleccionar] Expandir


    z=fmod(x,2);
if((x>0) && (x<28))
{
  if(z==1)

La validación del rango de valores ( de 1 a 27 ) debería comprobarse nada más recibir el dato por parte del usuario, no 6 líneas más abajo. Dicho de otra forma, si el usuario introduce un dato incorrecto lo normal es avisarle en ese mismo momento, además el código te quedará más claro.

Si lo que quieres saber es si un número es par o impar tienes opciones mucho más sencillas, rápidas y eficientes:

Código (c) [Seleccionar] Expandir


// Comprobar si el número es par
if ( x % 2 == 0 )

// Comprobar si el número es impar
if ( x % 2 != 0 )

Lo de que te salga mal el resultado ahora no lo puedo mirar porque no puedo compilar tu código ahora. Si tengo tiempo luego y nadie te ha contestado intento ayudarte más.

Un saludo.

El ejemplo que te pongo a continuación debería imprimir 00025

Código (c++) [Seleccionar] Expandir

cout << setfill('0') << setw(5) << 25;

* setfill configura el caracter de relleno.
* setw configura la longitud en caracteres de los valores que se pasen a continuación.

La función recursiva puede llamarse 40 veces, 100 o 2. Eso no depende de mi. Como ya he dicho se trata de hacer una estadística, y el llamar la función recursiva depende de números aleatorios. La primera llamada a la función recursiva es la que se hace 40 veces aprox antes de morir el programa. Vamos que antes de morir ha entrado y salido del "bucle de recursividad" unas 40 veces de forma satisfactoria. Ojala fuese tan fácil como cambiar la recursividad por un bucle! 


Pues parece que tienes razón porque al eliminar la recursividad de momento no me está dando fallos, pero la recursividad me es necesaria. Voy a probar a quitarle variables inútiles de esas que se quedan sueltas de cuando uno está construyendo el programa la primera vez para evitar que se desborde la pila. Esto que dices de la condición que hacia retornar no lo entiendo. ¿Puedes poner un ejemplo?

Muchas gracias por las respuestas, y un saludo a todos.

Aprovechando el ejemplo de Eternal....

Código (c) [Seleccionar] Expandir

/* Función recursiva para cálculo de factoriales */
int factorial(int n)
{
   if(n < 0) return 0;
   else if(n > 1) return n*factorial(n-1); /* Recursividad */
   return 1; /* Condicion de terminacion, n == 1 */
}

/* Función sin recursividad para cálculo de factoriales */
int factorial(int n)
{
   if(n < 0)
      return 0;

   int total = 1;

   while ( n > 1 )
   {
      total *= n;
      n--;
   }

   return total;
}

Es necesario que una función se llame de forma recursiva 40 veces ???

Lo mismo sería más lógico que no fuese recursiva y encerrar ese código en un bucle.

Vaya. Pues si, efectivamente estoy usando una función recursiva. Pero me parecería raro que fuese ahí el fallo porque únicamente le introduje unas variables nuevas que uso para comparar en condicionales...

Si los condicionales están mal diseñados y permiten que se sigua llamando de forma recursiva a la función cuando no deberían...

Tu piensa que cada llamada a una función supone meter datos en la pila. Una llamada recursiva que se llame a sí misma de forma descontrolada implica que la pila antes o después se va a desbordar... cuando eso pasa tu programa muere.

Antes de nada: El código enciérralo con las etiquetas GeSHi, así quedará más claro. es el combobox que está en la ventana de escritura de mensajes encima del combo que dice "Cambiar Color". Elige el lenguaje correspondiente, en tu caso c++.

Saludos quiero  probar si un vector me devuelve bien los datos antes de programar los datos que va recibir el constructor tengo un contructor en una biblioteca que he creado llamada NetXh.h y la forma del constructor es:
struct NetxInfo
{
public:
   ULONG pid;
   WCHAR filename[MAX_PATH];
   WCHAR pathname[MAX_PATH];

   WCHAR protocol[10];
   WCHAR state [MAX_PATH];
   WCHAR srcip[MAX_PATH];
   WCHAR destip[MAX_PATH];
};

Una aclaración: Lo que has puesto no es ningún constructor, tu ahí has definido una estructura. Un constructor es una función que crea e inicializa una estructura como la que tú has puesto.

En el caso de c++ el constructor tiene esta forma:

Código (cpp) [Seleccionar] Expandir


class NextInfo
{
  public:

    // ...

    // Constructor por defecto
    NextInfo( );

    // Constructor copia
    NextInfo( const NextInfo& original );
};

La implementación es libre, pero con lo que tienes lo más lógico es que fuese algo así:

Código (cpp) [Seleccionar] Expandir


NextInfo::NextInfo( )
{
  pid = 0;
  *filename = '\0';
  *pathname = '\0';
  *protocol = '\0';
  // ...
}

Como norma general, en c++ se usa la palabra clave "class" para definir clases nuevas. La diferencia entre "class" y "struct" en c++ es que por defecto en "class" los miembros son privados, mientras que en "struct" son públicos. En cualquier caso lo lógico y normal, como te he comentado, es usar "class".

Además, no se hasta qué punto es lógico que uses arrays de caracteres al estilo de C cuando en C++ tienes la clase string para gestionar cadenas de caracteres:

Código (cpp) [Seleccionar] Expandir


struct NetxInfo
{
public:
ULONG pid;
std::string filename;
        std::string pathname;

std::string protocol;
std::string state;
std::string srcip;
std::string destip;
};

Si en algún momento necesitas recuperar la cadena siguiendo la codificación de C, puedes usar el método c_str de la clase string:

Código (cpp) [Seleccionar] Expandir

char* cad_estilo_c = filename.c_str( );

Por defecto, en C++ no suele ser necesario la mayoría de las veces gestionar la memoria de forma dinámica ( muchas veces se hace más por inercia que por necesidad ). En tu caso no veo sentido a que el vector lo declares como un puntero:

Código (cpp) [Seleccionar] Expandir


// No tiene demasiado sentido
vector< NextInfo > * initialNetxes = new vector< NextInfo >( );

// Forma que yo creo sería más correcta
vector< NextInfo > initialNetxes;

La ventaja de definirlo de forma estática es que no tienes que preocuparte por la liberación de recursos. Además, si luego este vector lo vas a manejar en diferentes funciones no es necesario que pases "copias" del mismo, sino que lo puedes pasar por referencia:

Código (cpp) [Seleccionar] Expandir



// Al ser netxes una referencia, los cambios que realizemos en netxes se veran reflejados en el vector original
void RellenaVector( vector< NextInfo >& netxes )
{
  // ...
}

// En esta funcion se pone el modificador const para evitar que netxes pueda ser modificado dentro de la funcion.
// Si no pasamos el vector como referencia entonces se hara una copia en memoria del vector junto a todo su contenido
// y esa es una operacion que puede resultar bastante costosa, por lo que el rendimiento se resiente.
void ImprimeVector( const vector< NextInfo >& netxes )
{
  // ...
}

void main( )
{
  vector< NextInfo > initialNetxes;

  RellenaVector( initialNetxes );

  ImprimeVector( initialNetxes );
}

La ventaja de usar en la medida de lo posible objetos no dinámicos es que la gestión de la memoria puede llegar a ser algo realmente problemático y, con frecuencia, se suelen generar lagunas de memoria como consecuencia de despistes.

Para rellenar el vector puedes hacer algo como esto

Código (cpp) [Seleccionar] Expandir


void RellenaVector( vector< NextInfo >& netxes )
{
  NextInfo info;
  info.pid = 1;
  info.filename = "prueba.txt"; // lo trato como si fuese un string de c++, si lo dejas con tu implementacion estas lineas no valen
  info.pathname = "c:/dir_de_prueba";
  // ...

  netxes.push_back( info );

  info = NextInfo( ); // Reiniciamos el objeto info
  info.pid = 2;
  info.filename = "otro_fichero.bin";
  // ...

  netxes.push_back( info );

  // ...
}

Consideración final: No escribas código en los archivos de cabecera (.h), el código SIEMPRE debe ir en los cpp. Acostúmbrate a ser ordenado con tu código o luego lo vas a pasar realmente mal para corregir tus propios errores.

Hay algunas llamadas a la api de windows que, por alguna razón que no termino de entender, necesitan que la aplicación que las llama responda de alguna forma. Si el hilo principal de la aplicación se queda "atascado" en la dll, se ve que la aplicación no responde correctamente a las "llamadas o lo que sea que haga la api" y entonces la ejecución se atasca.

Prueba a crear un hilo en la dll que ejecute el código de forma independiente.

Es decir, al llamar a la función de la dll, ésta crea un hilo y ejecuta en dicho hilo el código ( deberás moverlo a una segunda función ).

los arrays no se pueden comparar directamente.

Lo que tu estás haciendo a nivel de código es lo siguiente: comparas la dirección de memoria donde se encuentra "cadena" con la posición de memoria en la que el programa ha almacenado la cadena "hola", dado que dichas posiciones son diferentes el resultado es siempre false.

Para comparar cadenas de caracteres de c usa strcmp, por ejemplo.

Aunque ya que estás incluyendo clases de c++... cambia el char* por un string y entonces la comparación si funcionará porque, al poner

Código (cpp) [Seleccionar] Expandir

if ( cadena == "hola" )

implícitamente se va a crear un string que va a contener la cadena hola y, después, se van a comparar ambos strings.