Mensajes

Código (cpp) [Seleccionar] Expandir

Excepcion(string mensaje,unsigned int Error) : Mensaje(Mensaje),N_Error(Error) {}; // Constructor

En esta linea deberías pasarle al constructor de Mensaje "mensaje" en minúscula. Quedando así:

Código (cpp) [Seleccionar] Expandir

Excepcion(string mensaje,unsigned int Error) : Mensaje(mensaje),N_Error(Error) {}; // Constructor

Funciono a la perfección, gracias!

Crea las clases Puerto, Cliente y Barco y les añades los metodos correspondientes a cada objeto (obtener mastiles en los Barco, obtener barcos veleros en Puerto...).

Sigo sin entenderlo, porque en el 2º paso del cout, no entiendo por qué dices que sigue siendo lo mismo, cuando antes de ello, ya se ha dicho que  ++m y --n, quedándome lo que se supone que tendría que salirme, m=46 y n=74. En el paso 3, según el libro, y es aquí donde no lo veo nada claro, antes de que salga en pantalla el reultado, dice que m++ y n--, pero que según mi guía, me tendría que salir que m=46 y n=73.

Vuelve a mirar bien estas lineas que te he pasado:

Código (cpp) [Seleccionar] Expandir

 // Reseteamos los valores
  m = 45;
  n = 75;

Despues de la primera operación, vuelvo a dejar los dos valores como estaba y hago la segunda.

Simplemente quería enseñarte que ambas operaciones daban lo mismo, si lo compilas lo podrás comprobar:



En cuanto al libro, debe ser una errata. Te debería dar n = 47 y m = 73

Realizan la misma operación: Incrementar uno. En el ejemplo que has puesto no se ve a simple vista porque has cambiado m y n previamente. Pero se puede ver si los vuelves a poner a estado normal:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
main(){
  int m = 45, n = 75;
  cout<< "m = " << m<< " n = "<< n << endl;
  // Aquí se entiende que m=45 y n=75
  ++m;
   --n;
  cout<< "m = " << m <<", n = " << n << endl;
 // Reseteamos los valores
  m = 45;
  n = 75;

  m++; // Incrementamos
  n--; // Decrementamos
  cout<< " m = "<< m <<", n = " << n << endl;
  // Ahora te deberia salir m = 46 y n = 74
  return 0;
}

Ponerlo en sufijo o prefijo no supone ninguna diferencia en operaciones simples. La diferencia sucede en operaciones más complejas:

Código (cpp) [Seleccionar] Expandir

C = A + ++B;
Primero se incrementa B y despues se suma.

Código (cpp) [Seleccionar] Expandir

C = A + B++;

Se suma primero y despues se incrementa el resultado.

Código (cpp) [Seleccionar] Expandir

case 1: puts("Generar y mostrar  5 números aleatorios del 1 al 10");
       printf("Numero aleatorio %d es : %d\n",i+1, rand()%10 );
       getch();
       main();
       break;
WTF? ¿Porque haces una llamada al main?.

Eso es super inestable, cada vez que llames a una función se iran creando llamadas proguesivamente gastando memoria y tiempo de ejecución.... Cuando te quedes sin pila el programa te crasheara estrepidosamente. Si lo que quieres esque el programa se repita continuamente ponlo dentro de un while:

Código (cpp) [Seleccionar] Expandir

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<conio.h>

int cubo ( int n )
{
   return n*n*n;
}
int multiplo ( int x, int y)
{
   return x%y;
}

int main()
{
   int i, temp,n1,n2;
   int _cont;
   int opc,numero,resultado;
   srand(time(NULL));

   while (true)
   {

       printf(" \n Menu  ");
       printf(" \n 1...Generar y mostrar  5 números aleatorios del 1 al 10  ");
       printf(" \n 2...Cubo de un número entero  ");
       printf(" \n 3...Determinar si un numero es múltiplo de otro  ");
       printf(" \n 4...Mostrar los números pares entre 1 y 40  ");
       printf(" \n 5...Salir  ");
       printf(" \n ESCOJA UNA OPCION  ");
       scanf("%d",opc);

       switch (opc)
       {

       case 1:
           puts("Generar y mostrar  5 números aleatorios del 1 al 10");
           printf("Numero aleatorio %d es : %d\n",i+1, rand()%10 );
           getch();

           break;
       case 2:
           puts("Cubo de un número entero");
           printf(" \n Ingrese un numero");
           scanf("%d",&numero);
           resultado = cubo(numero);
           printf("El cuadrado del numero es %d", resultado);
           getch();

           break;
       case 3:
           puts("Determinar si un numero es múltiplo de otro");
           printf(" \n Ingrese un numero");
           scanf("%d",&n1);
           printf(" \n Ingrese otro numero");
           scanf("%d",&n2);
           resultado=multiplo(n1,n2);
           if (n1%n2==0)
           {
               printf(" \n Los numeros son multiplos entre si");
           }
           else
           {
               printf(" \n Los numeros no son multiplos entre si");
           }
           getch();

           break;
       case 4:
           puts("Mostrar los números pares entre 1  y 40");
           while(_cont<=40)
           {
               if(_cont%2==0)
               {
                   printf("%d, ",_cont);
               }
               _cont++;
           }
           getch();

           break;
       case 5:
           puts("salir");
           printf("Fin del programa");
           getch();
           break;
       default:
           printf(" opcion invalalida");
       }
       getch();
       system("CLS"); // Comando para borrar la pantalla
   }
   system("pause");
}

También te he quitado el for del principio porque no servía para nada...

[Basada en la técnica de Hecky:]

He aquí, os presento un programa de esteganografía para archivos Rar: Rar File Missing.

Su uso es sencillo, creamos previamente un rar con los archivos:



Le pasamos el programa:



El programa nos detecta automáticamente el número de archivos que hay, ahora podemos ocultarlos a nuestro antojo. Por ejemplo quiero ocultar el archivo Cosa.txt porque allí escondí mi plan de asesinato al presidente



Ahora abrimos el nuevo archivo:



¡Ha desaparecido! Podemos descomprimirlo y comprobarlo. El archivo ha
desaparecido sin dejar rastro (0 mensajes de error, 0 advertencias...).

Para desbloquearlo solo es necesario abrirlo con el mismo programa y seleccionar la opcion "Mostrar"

Basada en la técnica de Hecky: http://neobits.org/?p=560

Descarga:

Rar_File_Missing Version Última versión (Source)

Rar_File_Missing Version ALPHA (WINDOWS)
Rar_File_Missing Version ALPHA (WINDOWS 64 BITS)
Rar_File_Missing Version ALPHA (LINUX)

Rar_File_Missing Version Primera versión (Source)

Vereis tengo una clase tal que asi:

Código (cpp) [Seleccionar] Expandir

using namespace std;

class Rar_File_Mising
{
private:
   ifstream Lectura;
   ofstream Escritura;
   // Demas metodos y variables...

public:
   // Constructor
    Rar_File_Mising(const char* Nombre,bool Opcion);

   //Metodos

   string ListarArchivos();

   void Generar(const char* Nombre,vector<unsigned int> Numero);

  //...

  // Excepciones...

   struct Excepcion
   {
       unsigned int N_Error; // Codigo de error
       string Mensaje; // Mensaje de error

       Excepcion(string mensaje,unsigned int Error) : Mensaje(Mensaje),N_Error(Error) {}; // Constructor
   };

   // Destructor

   ~Rar_File_Mising();

};

Como veis, he definido una estructura para definir las excepciones que me puedan ocurrir. De forma que si ocurre algo inesperado:

Código (cpp) [Seleccionar] Expandir

if (!Lectura.is_open())
       throw Excepcion("No hay ningun fichero abierto",ARCHIVO_NO_ABIERTO);

El problema esque no me las coge nunca en el bloque catch (ni siquiera en el bloque ...):

Código (cpp) [Seleccionar] Expandir

try
{
  Rar_File_Mising Nuevo(Nombre.c_str(),Opcion);
  cout<<Nuevo.ListarArchivos();
}
catch(Rar_File_Mising::Excepcion &E)
{
   cout<<E.Mensaje<<endl;
}
catch(...)
{
     cout<<"???";
}

¿Que es lo que puede pasar? Me acabo de cambiar al codeblocks hace poco, tengo que activar algo para que me admita las excepciones?

Si lo quieres hacer en C, entonces no uses el cout ni "using namespace std". Eso de ir a medias tintas no es muy correcto.

Este sería su equivalente en C:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

int main()
{
   FILE* Archivo;
   char* Lectura;
   char Nombre[255];
   int Tamanyo;

   do
   {
       printf("Introduce el nombre del archivo: ");
       scanf("%s",Nombre);
       Archivo = fopen(Nombre,"rb");
   }while(Archivo == NULL);

   Tamanyo = fseek(Archivo, 0L, SEEK_END );
   Tamanyo = ftell(Archivo);
   fseek(Archivo, 0L, SEEK_SET );

   Lectura =(char *)malloc(Tamanyo);

   fread(Lectura,sizeof(char),Tamanyo,Archivo);
   printf("%s",Lectura);

   fclose(Archivo);
   system("PAUSE");
   return 0;
}

Siempre que puedas, intenta no usar realloc en exceso. Te arriesgas a muchos fallos de memoria.

El error está en esta línea:

Código (cpp) [Seleccionar] Expandir

if(palabra[i]>64 && palabra[i]<91 || palabra[i]>96 && palabra[i]<123){
            cont=cont+1;
         }
El nombre del array no es palabra sino pal:

Código (cpp) [Seleccionar] Expandir

pal=new palabra[npalabras];

Por cierto, no tienes que poner private: ni public: en cada linea de la clase, lo puedes dejar asi:

Código (cpp) [Seleccionar] Expandir

class palabra
{
   private:
            string contenido;
            int nletras;
   public:

    palabra(){};
   palabra(string c, int nl)
   {
      contenido=c;
      nletras=nl;
   }
};

Y el compilador te entenderá perfectamente.

No uses malloc. En C++ tienes los operadores new[] y delete[] para eso:

Código (cpp) [Seleccionar] Expandir

a = new char[BLOQUEDETEXTO];

Y para leer desde un fichero tienes la clase ifstream:

Código (cpp) [Seleccionar] Expandir

ifstream Lectura;
Lectura.open(n,ios::binary);
Lectura.read(t,TamanyoArchivo);
Lectura.close();

Eso si, para poder usarlo necesitaras saber el tamanyo del archivo. Y para ello hay un truquillo bastante elemental:

Código (cpp) [Seleccionar] Expandir

ifstream Lectura;
Lectura.open(n);
Lectura.seekg(0,ios::end); // Nos vamos al final del archivo
int Tamanyo = Lectura.tellg(); /* Le pedimos que nos diga en que posicion del archivo esta y lo guardamos en una variable, ya tenemos el tamanyo del archivo */
Lectura.seekg(0,ios::beg); // Volvemos al principio

t = new char[Tamanyo]; // Creamos la memoria dinamica
Lectura.read(t,TamanyoTexto); // Leemos el texto
Lectura.close(); // Cerramos el archivo

Adaptando tu codigo a las librerias de C++ nos quedaría así:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <fstream> // Para la clase ifstream
#include <stdlib.h>

const int BLOQUEDETEXTO = 200 /* Los parametros constantes deben inicializarse con const y no con un define */

using namespace std;

int main() {
ifstream archivo;
char *t,*a; // t = texto seleccionado(200 bytes) , a = asignacion dinamica
int numerodetextos=0,textoseleccionado=0;
char n[255]; // nombre del archivo

//-------------------------------------------------------------
do
{

     cout<<"nombre del archivo: " ; cin>>n;
Archivo.open(n,ios::binary);
 if (!archivo)
 {

            cout<<"Nombre incorrecto";
        cout<<endl;
    }      
}
while(!archivo);

archivo.seekg(0,ios::end); // Nos vamos al final del archivo
int Tamanyo = archivo.tellg(); // Le pedimos que nos diga en que posicion del archivo esta y lo guardamos en una variable, ya tenemos el tamanyo del archivo
archivo.seekg(0,ios::beg); // Volvemos al principio

a = new char[Tamanyo]; // Creamos la memoria dinamica
archivo.read(a,TamanyoTexto); // Leemos el texto
Lectura.close(); // Cerramos el archivo

printf("\n %s",a);

delete[] a; // borramos la memoria dinámica usada

system("pause>nul");
   
return 0;

}