Mensajes

[(esto usando el ejemplo 3)]

de hecho esta muy interesante el error,

prueben esto:

vallan a la funcion "void encodeNotePad()"

y vallan a donde leemos 'filePad' que es aqui:

Código (cpp) [Seleccionar] Expandir

fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);

si despues de eso, le agregamos que nos imprima texty... quedaria asi...

Código (cpp) [Seleccionar] Expandir

fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);
std::cout << "texty:\n" << texty;
std::cout << "done\n"; //Sign

(esto usando el ejemplo 3)
vean lo que imprime texty...
esta inesperado...

imprime todo lo que leeyo + vuelve a imprimir parte del final (increible y no entiendo porque :p)

intente arreglar eso usando este codigo:

Código (cpp) [Seleccionar] Expandir

while(textyLength>counterEnter)
{
switch(texty[counterEnter])
{
case '\n' : counterEnter1++;
}
counterEnter++;
}

porque segun yo se copiaba de mas porque abian caracteres 'end of text' entonces intente por cada enter, borrar el 'end of text'

y tuvo exito, hasta que vi que quitaba parte del codigo

lo interesante es que si quitamos esto:

Código (cpp) [Seleccionar] Expandir

while(textyLength>counterEnter)
{
switch(texty[counterEnter])
{
case '\n' : counterEnter1++;
}
counterEnter++;
}

en vez de quitar codigo
imprime de mas 0.o

checare tu codigo (: se ve muy bueno y probablemente pueda aprender de tu codigo y si me das permiso "combinarlo" con el mio para poder hacer una codificacion todavia mas fuerte y cuando lo acabe compartirlo con todos (: .

si se decodifica a medias puede que sea que la variable que usas llego a su tope? y no puede descodificar más?

acabo de checar lo que comentaste ^^, gracias por la respuesta, le agrege mas texto, y si lo agarro todo y lo codifico, pero como de costumbre, le quito parte del final. (quita como 10 caracteres o 9), nose de que dependa

[Planteo el problema:]

Vi que hay gente que pide mucho codigos para codificar y decodificar textos por lo que decidi hacer uno para compartirlo (SENCILLO, ya que estoy aprendiendo), pero se me presento un problema...

Primero que nada aclaro que soy nuevo en esto de C++ por lo que cualquier critica constructiva es bienvenida!
Llevo trabajando 1 mes en este codigo, no es que sea complicado, es que e hecho muchas modificaciones, le falta mucho, pasara por mas capas de encriptacion
y mas detalles claro, pero hasta ahorita va asi.

Segundo:
la letra 'ñ' se pone diferente asi que...



del codigo hay una linea que se pone asi:
case 222111121: {fputs("ñ", Answer); break;}
buscala por el numero 222111121 para que no batalles
Remplazenla por:
case 222111121: {fputs("ñ", Answer); break;}

Y una linea que se pone asi:
case 'ñ': {fputs("222111121", textyEncrypted); break;}
Remplazenla por:
case 'ñ': {fputs("222111121", textyEncrypted); break;}

No se porque se pone asi y solo es aqui en esta pagina (probablemente tengo que hacer algo para poner esa letra pero nose como, pido perdon por eso)

Planteo el problema:
Tengo entendido que hay un caracter que se llama (end of text) y cuando uso 'fread' me lee eso tambien y creo que el error en este programa esta relacionado con eso.
En el ejemplo 3: no lo cifra completamente ya que hay un error y nose como corregirlo.

Ahora comparto el codigo y despues del codigo doy ejemplos del problema y como usar el codigo y ver le problema.

Código (cpp) [Seleccionar] Expandir

//1. Cuando te pida los nombres acabalos con (.txt)
// ejemplo: Si quires poner de nombre "codificado" entonces pondrias: Codificado.txt

//2. El error de alguna manera esta (segun yo) en que hay caracteres que lee
// como el "end of text" o algo asi se llama. El que esta despues de cada enter.
// y lo intente solucionar con lo que le llame "//Metodo Eliminar End Of File (SEGUN YO)"
// buscalo con control+f esta hasta abajo.

#include "stdafx.h"
#include <iostream>
#include <iomanip>

long op(); //Menu opciones.
void encodeNotePad(); //Codificar lo que este en un notepad.
void decodeToNotePad(); //Decodifica y lo pone en un notepad diferente.

int main()
{
long resultado = 0;
resultado = op();
switch(resultado)
{
case 1: encodeNotePad();
break;
case 2: decodeToNotePad();
break;
default: std::cout << "Sorry, not an option.";
break;
}
system ("pause");
return 0;
}

void decodeToNotePad()
{
char NombreNotePad[20] = ".";
char NombreNotePadFinal[20] = ".";
char textoLeer[500000] = "Failed.";
char textoTraductor[500000] = "Failed.";
long counter1 = 0;
long counter9 = 0;
long numero = 0;
long CharInt = 0;
long counterLast = 0;
long Snumber = 0;
char espacio[] = "13";
FILE * filePad;
FILE * Answer;

//Pide el nombre del archivo que quieres codificar
std::cout << "Name of the file to be decode\t"; std::cin >> NombreNotePad;
//Que nombre le quieres poner al archivo que va a resultar codificado?
std::cout << "New name for the file: \t"; std::cin >> NombreNotePadFinal;

//Abrimos los 2 (uno en forma de lecutra y el otro listo para escribir)
filePad = fopen(NombreNotePad, "r");
Answer = fopen(NombreNotePadFinal, "a+");

fopen (NombreNotePad, "r");
fopen (NombreNotePadFinal, "a+");

rewind(filePad);

//Aqui leemos el texto
fread(textoLeer, sizeof(char)|| sizeof(long), 500000-1, filePad);

//Se divide entre 9 porque cada 'forma de encriptacion' tiene 9 digitos
//ejemplo: a = 211111111
Snumber = (strlen(textoLeer))/9;
rewind(filePad);


while(counter1 < (Snumber))
{
//Va checando de 9 en 9
fseek(filePad, counter9, SEEK_CUR);
fread(textoTraductor, sizeof(char) || sizeof(long), 9, filePad);
CharInt = atoi(textoTraductor);

switch(CharInt)
{
case 211111111: {fputs(" ", Answer); break;}
case 222221221: {fputs("a", Answer); break;}
case 221111111: {fputs("b", Answer); break;}
case 111112121: {fputs("c", Answer); break;}
case 222211111: {fputs("d", Answer); break;}
case 222222221: {fputs("e", Answer); break;}
case 222221111: {fputs("f", Answer); break;}
case 222212212: {fputs("g", Answer); break;}
case 111111222: {fputs("h", Answer); break;}
case 222122122: {fputs("i", Answer); break;}
case 221122111: {fputs("j", Answer); break;}
case 111122222: {fputs("k", Answer); break;}
case 222212122: {fputs("l", Answer); break;}
case 122221111: {fputs("m", Answer); break;}
case 121111111: {fputs("n", Answer); break;}
case 221221222: {fputs("o", Answer); break;}
case 112211221: {fputs("p", Answer); break;}
case 111121211: {fputs("q", Answer); break;}
case 221122222: {fputs("r", Answer); break;}
case 222221212: {fputs("s", Answer); break;}
case 122221222: {fputs("t", Answer); break;}
case 222111111: {fputs("u", Answer); break;}
case 112212111: {fputs("v", Answer); break;}
case 111111212: {fputs("w", Answer); break;}
case 222222121: {fputs("x", Answer); break;}
case 111112112: {fputs("y", Answer); break;}
case 221111121: {fputs("z", Answer); break;}
case 112111111: {fputs("A", Answer); break;}
case 111222221: {fputs("B", Answer); break;}
case 122212222: {fputs("C", Answer); break;}
case 112222111: {fputs("D", Answer); break;}
case 212222222: {fputs("E", Answer); break;}
case 122222221: {fputs("F", Answer); break;}
case 111111221: {fputs("G", Answer); break;}
case 122122221: {fputs("H", Answer); break;}
case 121211111: {fputs("I", Answer); break;}
case 111111122: {fputs("J", Answer); break;}
case 121111112: {fputs("K", Answer); break;}
case 111211111: {fputs("L", Answer); break;}
case 211212212: {fputs("M", Answer); break;}
case 212212222: {fputs("N", Answer); break;}
case 122222211: {fputs("O", Answer); break;}
case 222111221: {fputs("P", Answer); break;}
case 122211111: {fputs("Q", Answer); break;}
case 221212222: {fputs("R", Answer); break;}
case 211112111: {fputs("S", Answer); break;}
case 112211111: {fputs("T", Answer); break;}
case 112111211: {fputs("U", Answer); break;}
case 211111112: {fputs("V", Answer); break;}
case 111222211: {fputs("W", Answer); break;}
case 122222122: {fputs("X", Answer); break;}
case 211211111: {fputs("Y", Answer); break;}
case 111221111: {fputs("Z", Answer); break;}
case 122111111: {fputs("0", Answer); break;}
case 222222222: {fputs("1", Answer); break;}
case 122122222: {fputs("2", Answer); break;}
case 111112222: {fputs("3", Answer); break;}
case 212122222: {fputs("4", Answer); break;}
case 111122211: {fputs("5", Answer); break;}
case 222221222: {fputs("6", Answer); break;}
case 121222222: {fputs("7", Answer); break;}
case 222122222: {fputs("8", Answer); break;}
case 111121111: {fputs("9", Answer); break;}
case 212221111: {fputs("{", Answer); break;}
case 111222112: {fputs("}", Answer); break;}
case 111212111: {fputs("(", Answer); break;}
case 211121111: {fputs(")", Answer); break;}
case 222121222: {fputs("<", Answer); break;}
case 112121111: {fputs(">", Answer); break;}
case 221122122: {fputs("|", Answer); break;}
case 112121212: {fputs(",", Answer); break;}
case 122222111: {fputs("/", Answer); break;}
case 111121112: {fputs(";", Answer); break;}
case 111222111: {fputs(":", Answer); break;}
case 222212222: {fputs("+", Answer); break;}
case 111122111: {fputs("-", Answer); break;}
case 222222212: {fputs("*", Answer); break;}
case 222222122: {fputs("@", Answer); break;}
case 111211211: {fputs("?", Answer); break;}
case 221222222: {fputs(".", Answer); break;}
case 111111121: {fputs("&", Answer); break;}
case 111112221: {fputs("$", Answer); break;}
case 112222211: {fputs("%", Answer); break;}
case 111112211: {fputs("!", Answer); break;}
case 211211211: {fputs("^", Answer); break;}
case 112221222: {fputs("\n", Answer); break;}
case 112221211: {fputs("_", Answer); break;}
case 112211212: {fputs(" ", Answer); break;}
case 111111211: {fputs("\"", Answer); break;}
case 111111112: {fputs("\'", Answer); break;}
case 222111121: {fputs("ñ", Answer); break;}
case 212111111: {fputs("#", Answer); break;}
case 111111111: {fputs("=", Answer); break;}
case 121111121: {fputs("[", Answer); break;}
case 222212121: {fputs("]", Answer); break;}
case 222211122: {fputs("\\", Answer); break;}

//Si hay un caracter que no existe, pone 123456789
default: {fputs("123456789", Answer); break;}

}
counterLast++; numero++; counter1++; counter9+9;
}
fclose(Answer);
fclose(filePad);
}

void encodeNotePad()
{
char NotePad[20] = ".";
char NotePadResult[20] = ".";
char texty[500000] = ".";
long textyLength;
FILE * filePad;
FILE * textyEncrypted;
long counter = 0;
long counterEnter = 0;
long counterEnter1 = 0;

std::cout << "Name of the file to encode: \t"; std::cin >> NotePad;
std::cout << "Name of the new file: \t"; std::cin >> NotePadResult;
system("cls");

filePad = fopen(NotePad, "r");
std::cout << "File A:\tFile to be encoded.\n";
std::cout << "File B:\tFile encoded.\n";
std::cout << "\nLooking for file A...\t"; //Sign
if(filePad)
{
std::cout << "done\n"; //Sign
rewind(filePad);
std::cout << "Reading file A...\t"; //Sign
fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);

std::cout << "done\n"; //Sign

textyLength = strlen(texty);
std::cout << "\nTextLength\t" << textyLength << std::endl;

std::cout << "Closing file A...\t"; //Sign
fclose(filePad);
std::cout << "done\n"; //Sign

//Quita el 'text of file' despues de cada enter. (SEGUN YO AKI HAY UN ERROR)
//Metodo Eliminar End Of File (SEGUN YO)
while(textyLength>counterEnter)
{
switch(texty[counterEnter])
{
case '\n' : counterEnter1++;
}
counterEnter++;
}
std::cout << "\nNumeros de enter:\t" << counterEnter1 << std::endl;

std::cout << "\nLooking for file B...\t";
textyEncrypted = fopen(NotePadResult, "a+");
std::cout << "done"; //Sign

//Aqui restamos el numero de enter (que serian los text of end sobrantes)
//para que solo queden los caracteres normales.
textyLength = textyLength - counterEnter1;
std::cout << "\nTextLength\t" << textyLength << std::endl;
std::cout << "\nEncoding file B...\t";
while(textyLength>counter)
{
switch(texty[counter])
{
case ' ': {fputs("211111111", textyEncrypted); break;}
case 'a': {fputs("222221221", textyEncrypted); break;}
case 'b': {fputs("221111111", textyEncrypted); break;}
case 'c': {fputs("111112121", textyEncrypted); break;}
case 'd': {fputs("222211111", textyEncrypted); break;}
case 'e': {fputs("222222221", textyEncrypted); break;}
case 'f': {fputs("222221111", textyEncrypted); break;}
case 'g': {fputs("222212212", textyEncrypted); break;}
case 'h': {fputs("111111222", textyEncrypted); break;}
case 'i': {fputs("222122122", textyEncrypted); break;}
case 'j': {fputs("221122111", textyEncrypted); break;}
case 'k': {fputs("111122222", textyEncrypted); break;}
case 'l': {fputs("222212122", textyEncrypted); break;}
case 'm': {fputs("122221111", textyEncrypted); break;}
case 'n': {fputs("121111111", textyEncrypted); break;}
case 'o': {fputs("221221222", textyEncrypted); break;}
case 'p': {fputs("112211221", textyEncrypted); break;}
case 'q': {fputs("111121211", textyEncrypted); break;}
case 'r': {fputs("221122222", textyEncrypted); break;}
case 's': {fputs("222221212", textyEncrypted); break;}
case 't': {fputs("122221222", textyEncrypted); break;}
case 'u': {fputs("222111111", textyEncrypted); break;}
case 'v': {fputs("112212111", textyEncrypted); break;}
case 'w': {fputs("111111212", textyEncrypted); break;}
case 'x': {fputs("222222121", textyEncrypted); break;}
case 'y': {fputs("111112112", textyEncrypted); break;}
case 'z': {fputs("221111121", textyEncrypted); break;}
case 'A': {fputs("112111111", textyEncrypted); break;}
case 'B': {fputs("111222221", textyEncrypted); break;}
case 'C': {fputs("122212222", textyEncrypted); break;}
case 'D': {fputs("112222111", textyEncrypted); break;}
case 'E': {fputs("212222222", textyEncrypted); break;}
case 'F': {fputs("122222221", textyEncrypted); break;}
case 'G': {fputs("111111221", textyEncrypted); break;}
case 'H': {fputs("122122221", textyEncrypted); break;}
case 'I': {fputs("121211111", textyEncrypted); break;}
case 'J': {fputs("111111122", textyEncrypted); break;}
case 'K': {fputs("121111112", textyEncrypted); break;}
case 'L': {fputs("111211111", textyEncrypted); break;}
case 'M': {fputs("211212212", textyEncrypted); break;}
case 'N': {fputs("212212222", textyEncrypted); break;}
case 'O': {fputs("122222211", textyEncrypted); break;}
case 'P': {fputs("222111221", textyEncrypted); break;}
case 'Q': {fputs("122211111", textyEncrypted); break;}
case 'R': {fputs("221212222", textyEncrypted); break;}
case 'S': {fputs("211112111", textyEncrypted); break;}
case 'T': {fputs("112211111", textyEncrypted); break;}
case 'U': {fputs("112111211", textyEncrypted); break;}
case 'V': {fputs("211111112", textyEncrypted); break;}
case 'W': {fputs("111222211", textyEncrypted); break;}
case 'X': {fputs("122222122", textyEncrypted); break;}
case 'Y': {fputs("211211111", textyEncrypted); break;}
case 'Z': {fputs("111221111", textyEncrypted); break;}
case '#': {fputs("212111111", textyEncrypted); break;}
case '0': {fputs("122111111", textyEncrypted); break;}
case '1': {fputs("222222222", textyEncrypted); break;}
case '2': {fputs("122122222", textyEncrypted); break;}
case '3': {fputs("111112222", textyEncrypted); break;}
case '4': {fputs("212122222", textyEncrypted); break;}
case '5': {fputs("111122211", textyEncrypted); break;}
case '6': {fputs("222221222", textyEncrypted); break;}
case '7': {fputs("121222222", textyEncrypted); break;}
case '8': {fputs("222122222", textyEncrypted); break;}
case '9': {fputs("111121111", textyEncrypted); break;}
case '{': {fputs("212221111", textyEncrypted); break;}
case '}': {fputs("111222112", textyEncrypted); break;}
case '"': {fputs("111111211", textyEncrypted); break;}
case '=': {fputs("111111111", textyEncrypted); break;}
case '(': {fputs("111212111", textyEncrypted); break;}
case ')': {fputs("211121111", textyEncrypted); break;}
case '<': {fputs("222121222", textyEncrypted); break;}
case '>': {fputs("112121111", textyEncrypted); break;}
case '|': {fputs("221122122", textyEncrypted); break;}
case ',': {fputs("112121212", textyEncrypted); break;}
case '/': {fputs("122222111", textyEncrypted); break;}
case ';': {fputs("111121112", textyEncrypted); break;}
case ':': {fputs("111222111", textyEncrypted); break;}
case '+': {fputs("222212222", textyEncrypted); break;}
case '-': {fputs("111122111", textyEncrypted); break;}
case '*': {fputs("222222212", textyEncrypted); break;}
case '@': {fputs("222222122", textyEncrypted); break;}
case '?': {fputs("111211211", textyEncrypted); break;}
case '.': {fputs("221222222", textyEncrypted); break;}
case '&': {fputs("111111121", textyEncrypted); break;}
case '$': {fputs("111112221", textyEncrypted); break;}
case '%': {fputs("112222211", textyEncrypted); break;}
case '!': {fputs("111112211", textyEncrypted); break;}
case '^': {fputs("211211211", textyEncrypted); break;}
case '_': {fputs("112221211", textyEncrypted); break;}
case '\n': {fputs("112221222", textyEncrypted); break;}
case ' ': {fputs("112211212", textyEncrypted); break;}
case '\'': {fputs("111111112", textyEncrypted); break;}
case 'ñ': {fputs("222111121", textyEncrypted); break;}
case '[': {fputs("121111121", textyEncrypted); break;}
case ']': {fputs("222212121", textyEncrypted); break;}
case '\\': {fputs("222211122", textyEncrypted); break;}

default: {fputs("123456789", textyEncrypted); break;}
}
counter++;
}
std::cout << "done\n"; //Sign
std::cout << "Closing file B...\t"; //Sign
fclose(textyEncrypted);
std::cout << "done\n"; //Sign

std::cout << "\n\n\n\n*-----------------------*\n";
std::cout << "*-----------------------*";
std::cout << "\n\nEncryption completed\n\n";
std::cout << "*-----------------------*\n";
std::cout << "*-----------------------*\n\n\n\n";
}
else
{
std::cout << "Fail\n\n\n";
}
}

long op()
{
long opciones;
std::cout << "Select an option:" << std::endl;
// std::cout << "_____________________________________\n" << std::endl;
std::cout << "\n";
std::cout << "1.Encode notepad\t" << std::endl;
std::cout << "2.Decode notepad\t" << std::endl;
// std::cout << "\n_____________________________________" << std::endl;
std::cin >> opciones;
system("cls");
return opciones;
}

Ahora, para usarlo tenemos que crear un Bloc de notas y ponle el nombre que quieras. Vamos a empezar a probarlo.

Ejemplo 1 <Funciona bien>
Agrega este texto al bloc de notas.

ImageNet is an image dataset organized according to the WordNet hierarchy. Each meaningful concept in WordNet, possibly described by multiple words or word phrases, is called a "synonym set" or "synset". There are more than 100,000 synsets in WordNet, majority of them are nouns (80,000+). In ImageNet, we aim to provide on average 1000 images to illustrate each synset. Images of each concept are quality-controlled and human-annotated. In its completion, we hope ImageNet will offer tens of millions of cleanly sorted images for most of the concepts in...

------Para codificar------
1. Corre el programa
2. Pon la opcion '1' que es "1. Encode notepad"
3. Pon el nombre de tu archivo + .txt si mi archivo se llama "a", entonces pondre "a.txt".
4. Pon otro nombre (sera el documento cifrado). Recuerda agregarle .txt, si mi archivo se llamara "b", entonces pondre "b.txt".
5. Busca el archivo con el segundo nombre en tu carpeta donde estas corriendo este programa. (si lo abres veras que son puros numeros).

Ahora vamos a decodificarlo.
------Para decodificar------
1. Corre el programa
2. Pon la opcion '2' que es "2. Decode notepad"
3. Pon el nombre del archivo CIFRADO, en mi caso seria "b.txt".
4. Ahora ponemos el nombre de como va a quedar decodificado, yo pondre "c.txt"
5. Buscalo el archivo "c.txt" y veelo. (Es igual al enterior)


Ejemplo 2 <Funciona bien>

Ahora vamos a probar con algo mas complejo... Sigue los mismos pasos (aqui la diferencia es que si hay un caracter que no tengo registrado, nos pone 123456789) <si quieres pruebalo o saltate al siguiente, en el siguiente hay un error>

Esta vez vamos a codificar este texto:

Ahora el uso de la computadora es muy común, tanto en empresas, negocios y algunos hogares.

Pero cuando personas relacionadas con las antes mencionadas interactúan con la computadora la mayoría de las veces solo piensan que todas las computadoras son del mismo tipo.

Además que quieren tener mas información acerca de las computadoras y no saben ?los tipos de computadoras que existen? y esto es una limitante para que las personas, que interactúan con ellas, sepan acerca de la computación


Las computadoras se clasifican en súper computadoras, macro computadoras o mainframes, mini computadoras y micro computadoras o PC.

Las clasificaciones contienen un cierto tipo de computadoras con características especificas.


Supercomputadoras
Una supercomputadora es le tipo de computadora más potente y más rápido que existe en un momento dado. Estas maquinas están diseñadas para procesar enormes cantidades de información en poco tiempo y son dedicadas a una tarea especifica.

Un ejemplo de súper computadora es una computadora que se utiliza para el manejo de un grupo de maquinas ensambladoras de productos metálicos.

Ejemplo 3<Error!!>

Nota: Sigue los mismos pasos, pero ve que al final no se decodifico completamente.

Vamos a codificar el MISMO CODIGO QUE ESTAMOS USANDO, si, el codigo que estamos usando para codificar y decodificar, vas a copiarlo y pegarlo a tu bloc de notas. Osea:

copia este texto citado y pegalo en tu bloc de notas y pruebalo, al final veras que falta texto:

//1. Cuando te pida los nombres acabalos con (.txt)
//    ejemplo: Si quires poner de nombre "codificado" entonces pondrias: Codificado.txt

//2. El error de alguna manera esta (segun yo) en que hay caracteres que lee
//    como el "end of text" o algo asi se llama. El que esta despues de cada enter.
//    y lo intente solucionar con lo que le llame "//Metodo Eliminar End Of File (SEGUN YO)"
//    buscalo con control+f esta hasta abajo.

#include "stdafx.h"
#include <iostream>
#include <iomanip>

long op();                  //Menu opciones.
void encodeNotePad();         //Codificar lo que este en un notepad.
void decodeToNotePad();         //Decodifica y lo pone en un notepad diferente.

int main()
{
      long resultado = 0;
      resultado = op();
      switch(resultado)
      {
         case 1: encodeNotePad();
            break;
         case 2: decodeToNotePad();
            break;   
         default: std::cout << "Sorry, not an option.";
            break;
      }
   system ("pause");
   return 0;
}

void decodeToNotePad()
{
   char NombreNotePad[20] = ".";
   char NombreNotePadFinal[20] = ".";
   char textoLeer[500000] = "Failed.";
   char textoTraductor[500000] = "Failed.";
   long counter1 = 0;
   long counter9 = 0;
   long numero = 0;
   long CharInt = 0;
   long counterLast = 0;
   long Snumber = 0;
   char espacio[] = "13";
   FILE * filePad;
   FILE * Answer;

   //Pide el nombre del archivo que quieres codificar
   std::cout << "Name of the file to be decode\t";   std::cin >> NombreNotePad;
   //Que nombre le quieres poner al archivo que va a resultar codificado?
   std::cout << "New name for the file: \t";   std::cin >> NombreNotePadFinal;
   
   //Abrimos los 2 (uno en forma de lecutra y el otro listo para escribir)
   filePad = fopen(NombreNotePad, "r");
   Answer = fopen(NombreNotePadFinal, "a+");

   fopen (NombreNotePad, "r");
   fopen (NombreNotePadFinal, "a+");

   rewind(filePad);

   //Aqui leemos el texto
   fread(textoLeer, sizeof(char)|| sizeof(long), 500000-1, filePad);
   
   //Se divide entre 9 porque cada 'forma de encriptacion' tiene 9 digitos
   //ejemplo: a = 211111111
   Snumber = (strlen(textoLeer))/9;
   rewind(filePad);


   while(counter1 < (Snumber))
   {
      //Va checando de 9 en 9
      fseek(filePad, counter9, SEEK_CUR);
      fread(textoTraductor, sizeof(char) || sizeof(long), 9, filePad);
      CharInt = atoi(textoTraductor);

      switch(CharInt)
      {
         case 211111111: {fputs(" ", Answer); break;}
         case 222221221: {fputs("a", Answer); break;}
         case 221111111: {fputs("b", Answer); break;}
         case 111112121: {fputs("c", Answer); break;}
         case 222211111: {fputs("d", Answer); break;}
         case 222222221: {fputs("e", Answer); break;}
         case 222221111: {fputs("f", Answer); break;}
         case 222212212: {fputs("g", Answer); break;}
         case 111111222: {fputs("h", Answer); break;}
         case 222122122: {fputs("i", Answer); break;}
         case 221122111: {fputs("j", Answer); break;}
         case 111122222: {fputs("k", Answer); break;}
         case 222212122: {fputs("l", Answer); break;}
         case 122221111: {fputs("m", Answer); break;}
         case 121111111: {fputs("n", Answer); break;}
         case 221221222: {fputs("o", Answer); break;}
         case 112211221: {fputs("p", Answer); break;}
         case 111121211: {fputs("q", Answer); break;}
         case 221122222: {fputs("r", Answer); break;}
         case 222221212: {fputs("s", Answer); break;}
         case 122221222: {fputs("t", Answer); break;}
         case 222111111: {fputs("u", Answer); break;}
         case 112212111: {fputs("v", Answer); break;}
         case 111111212: {fputs("w", Answer); break;}
         case 222222121: {fputs("x", Answer); break;}
         case 111112112: {fputs("y", Answer); break;}
         case 221111121: {fputs("z", Answer); break;}
         case 112111111: {fputs("A", Answer); break;}
         case 111222221: {fputs("B", Answer); break;}
         case 122212222: {fputs("C", Answer); break;}
         case 112222111: {fputs("D", Answer); break;}
         case 212222222: {fputs("E", Answer); break;}
         case 122222221: {fputs("F", Answer); break;}
         case 111111221: {fputs("G", Answer); break;}
         case 122122221: {fputs("H", Answer); break;}
         case 121211111: {fputs("I", Answer); break;}
         case 111111122: {fputs("J", Answer); break;}
         case 121111112: {fputs("K", Answer); break;}
         case 111211111: {fputs("L", Answer); break;}
         case 211212212: {fputs("M", Answer); break;}
         case 212212222: {fputs("N", Answer); break;}
         case 122222211: {fputs("O", Answer); break;}
         case 222111221: {fputs("P", Answer); break;}
         case 122211111: {fputs("Q", Answer); break;}
         case 221212222: {fputs("R", Answer); break;}
         case 211112111: {fputs("S", Answer); break;}
         case 112211111: {fputs("T", Answer); break;}
         case 112111211: {fputs("U", Answer); break;}
         case 211111112: {fputs("V", Answer); break;}
         case 111222211: {fputs("W", Answer); break;}
         case 122222122: {fputs("X", Answer); break;}
         case 211211111: {fputs("Y", Answer); break;}
         case 111221111: {fputs("Z", Answer); break;}
         case 122111111: {fputs("0", Answer); break;}
         case 222222222: {fputs("1", Answer); break;}
         case 122122222: {fputs("2", Answer); break;}
         case 111112222: {fputs("3", Answer); break;}
         case 212122222: {fputs("4", Answer); break;}
         case 111122211: {fputs("5", Answer); break;}
         case 222221222: {fputs("6", Answer); break;}
         case 121222222: {fputs("7", Answer); break;}
         case 222122222: {fputs("8", Answer); break;}
         case 111121111: {fputs("9", Answer); break;}
         case 212221111: {fputs("{", Answer); break;}
         case 111222112: {fputs("}", Answer); break;}
         case 111212111: {fputs("(", Answer); break;}
         case 211121111: {fputs(")", Answer); break;}
         case 222121222: {fputs("<", Answer); break;}
         case 112121111: {fputs(">", Answer); break;}
         case 221122122: {fputs("|", Answer); break;}
         case 112121212: {fputs(",", Answer); break;}
         case 122222111: {fputs("/", Answer); break;}
         case 111121112: {fputs(";", Answer); break;}
         case 111222111: {fputs(":", Answer); break;}
         case 222212222: {fputs("+", Answer); break;}
         case 111122111: {fputs("-", Answer); break;}
         case 222222212: {fputs("*", Answer); break;}
         case 222222122: {fputs("@", Answer); break;}
         case 111211211: {fputs("?", Answer); break;}
         case 221222222: {fputs(".", Answer); break;}
         case 111111121: {fputs("&", Answer); break;}
         case 111112221: {fputs("$", Answer); break;}
         case 112222211: {fputs("%", Answer); break;}
         case 111112211: {fputs("!", Answer); break;}
         case 211211211: {fputs("^", Answer); break;}
         case 112221222: {fputs("\n", Answer); break;}
         case 112221211: {fputs("_", Answer); break;}
         case 112211212: {fputs("   ", Answer); break;}
         case 111111211: {fputs("\"", Answer); break;}
         case 111111112: {fputs("\'", Answer); break;}
         case 222111121: {fputs("ñ", Answer); break;}
         case 212111111: {fputs("#", Answer); break;}
         case 111111111: {fputs("=", Answer); break;}
         case 121111121: {fputs("[", Answer); break;}
         case 222212121: {fputs("]", Answer); break;}
         case 222211122: {fputs("\\", Answer); break;}

         //Si hay un caracter que no existe, pone 123456789
         default: {fputs("123456789", Answer); break;}

      }
      counterLast++; numero++; counter1++; counter9+9;
   }
   fclose(Answer);
   fclose(filePad);   
}

void encodeNotePad()
{
   char NotePad[20] = ".";
   char NotePadResult[20] = ".";
   char texty[500000] = ".";
   long textyLength;
   FILE * filePad;
   FILE * textyEncrypted;
   long counter = 0;
   long counterEnter = 0;
   long counterEnter1 = 0;

   std::cout << "Name of the file to encode: \t";   std::cin >> NotePad;
   std::cout << "Name of the new file: \t";   std::cin >> NotePadResult;
   system("cls");
      
   filePad = fopen(NotePad, "r");
   std::cout << "File A:\tFile to be encoded.\n";
   std::cout << "File B:\tFile encoded.\n";
   std::cout << "\nLooking for file A...\t";   //Sign
   if(filePad)
   {   
      std::cout << "done\n";   //Sign
      rewind(filePad);
      std::cout << "Reading file A...\t";   //Sign
      fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);
      
      std::cout << "done\n";   //Sign
      
      textyLength = strlen(texty);
      std::cout << "\nTextLength\t" << textyLength << std::endl;

      std::cout << "Closing file A...\t";   //Sign
      fclose(filePad);
      std::cout << "done\n";   //Sign

      //Quita el 'text of file' despues de cada enter. (SEGUN YO AKI HAY UN ERROR)
      //Metodo Eliminar End Of File (SEGUN YO)
      while(textyLength>counterEnter)
      {
         switch(texty[counterEnter])
         {
            case '\n' : counterEnter1++;
         }
         counterEnter++;
      }
      std::cout << "\nNumeros de enter:\t" << counterEnter1 << std::endl;
      
      std::cout << "\nLooking for file B...\t";
      textyEncrypted = fopen(NotePadResult, "a+");
      std::cout << "done";   //Sign

      //Aqui restamos el numero de enter (que serian los text of end sobrantes)
      //para que solo queden los caracteres normales.
      textyLength = textyLength - counterEnter1;
      std::cout << "\nTextLength\t" << textyLength << std::endl;
      std::cout << "\nEncoding file B...\t";
      while(textyLength>counter)
      {
         switch(texty[counter])
         {
            case ' ': {fputs("211111111", textyEncrypted); break;}
            case 'a': {fputs("222221221", textyEncrypted); break;}
            case 'b': {fputs("221111111", textyEncrypted); break;}
            case 'c': {fputs("111112121", textyEncrypted); break;}
            case 'd': {fputs("222211111", textyEncrypted); break;}
            case 'e': {fputs("222222221", textyEncrypted); break;}
            case 'f': {fputs("222221111", textyEncrypted); break;}
            case 'g': {fputs("222212212", textyEncrypted); break;}
            case 'h': {fputs("111111222", textyEncrypted); break;}
            case 'i': {fputs("222122122", textyEncrypted); break;}
            case 'j': {fputs("221122111", textyEncrypted); break;}
            case 'k': {fputs("111122222", textyEncrypted); break;}
            case 'l': {fputs("222212122", textyEncrypted); break;}
            case 'm': {fputs("122221111", textyEncrypted); break;}
            case 'n': {fputs("121111111", textyEncrypted); break;}
            case 'o': {fputs("221221222", textyEncrypted); break;}
            case 'p': {fputs("112211221", textyEncrypted); break;}
            case 'q': {fputs("111121211", textyEncrypted); break;}
            case 'r': {fputs("221122222", textyEncrypted); break;}
            case 's': {fputs("222221212", textyEncrypted); break;}
            case 't': {fputs("122221222", textyEncrypted); break;}
            case 'u': {fputs("222111111", textyEncrypted); break;}
            case 'v': {fputs("112212111", textyEncrypted); break;}
            case 'w': {fputs("111111212", textyEncrypted); break;}
            case 'x': {fputs("222222121", textyEncrypted); break;}
            case 'y': {fputs("111112112", textyEncrypted); break;}
            case 'z': {fputs("221111121", textyEncrypted); break;}
            case 'A': {fputs("112111111", textyEncrypted); break;}
            case 'B': {fputs("111222221", textyEncrypted); break;}
            case 'C': {fputs("122212222", textyEncrypted); break;}
            case 'D': {fputs("112222111", textyEncrypted); break;}
            case 'E': {fputs("212222222", textyEncrypted); break;}
            case 'F': {fputs("122222221", textyEncrypted); break;}
            case 'G': {fputs("111111221", textyEncrypted); break;}
            case 'H': {fputs("122122221", textyEncrypted); break;}
            case 'I': {fputs("121211111", textyEncrypted); break;}
            case 'J': {fputs("111111122", textyEncrypted); break;}
            case 'K': {fputs("121111112", textyEncrypted); break;}
            case 'L': {fputs("111211111", textyEncrypted); break;}
            case 'M': {fputs("211212212", textyEncrypted); break;}
            case 'N': {fputs("212212222", textyEncrypted); break;}
            case 'O': {fputs("122222211", textyEncrypted); break;}
            case 'P': {fputs("222111221", textyEncrypted); break;}
            case 'Q': {fputs("122211111", textyEncrypted); break;}
            case 'R': {fputs("221212222", textyEncrypted); break;}
            case 'S': {fputs("211112111", textyEncrypted); break;}
            case 'T': {fputs("112211111", textyEncrypted); break;}
            case 'U': {fputs("112111211", textyEncrypted); break;}
            case 'V': {fputs("211111112", textyEncrypted); break;}
            case 'W': {fputs("111222211", textyEncrypted); break;}
            case 'X': {fputs("122222122", textyEncrypted); break;}
            case 'Y': {fputs("211211111", textyEncrypted); break;}
            case 'Z': {fputs("111221111", textyEncrypted); break;}
            case '#': {fputs("212111111", textyEncrypted); break;}
            case '0': {fputs("122111111", textyEncrypted); break;}
            case '1': {fputs("222222222", textyEncrypted); break;}
            case '2': {fputs("122122222", textyEncrypted); break;}
            case '3': {fputs("111112222", textyEncrypted); break;}
            case '4': {fputs("212122222", textyEncrypted); break;}
            case '5': {fputs("111122211", textyEncrypted); break;}
            case '6': {fputs("222221222", textyEncrypted); break;}
            case '7': {fputs("121222222", textyEncrypted); break;}
            case '8': {fputs("222122222", textyEncrypted); break;}
            case '9': {fputs("111121111", textyEncrypted); break;}
            case '{': {fputs("212221111", textyEncrypted); break;}
            case '}': {fputs("111222112", textyEncrypted); break;}
            case '"': {fputs("111111211", textyEncrypted); break;}
            case '=': {fputs("111111111", textyEncrypted); break;}
            case '(': {fputs("111212111", textyEncrypted); break;}
            case ')': {fputs("211121111", textyEncrypted); break;}
            case '<': {fputs("222121222", textyEncrypted); break;}
            case '>': {fputs("112121111", textyEncrypted); break;}
            case '|': {fputs("221122122", textyEncrypted); break;}
            case ',': {fputs("112121212", textyEncrypted); break;}
            case '/': {fputs("122222111", textyEncrypted); break;}
            case ';': {fputs("111121112", textyEncrypted); break;}
            case ':': {fputs("111222111", textyEncrypted); break;}
            case '+': {fputs("222212222", textyEncrypted); break;}
            case '-': {fputs("111122111", textyEncrypted); break;}
            case '*': {fputs("222222212", textyEncrypted); break;}
            case '@': {fputs("222222122", textyEncrypted); break;}
            case '?': {fputs("111211211", textyEncrypted); break;}
            case '.': {fputs("221222222", textyEncrypted); break;}
            case '&': {fputs("111111121", textyEncrypted); break;}
            case '$': {fputs("111112221", textyEncrypted); break;}
            case '%': {fputs("112222211", textyEncrypted); break;}
            case '!': {fputs("111112211", textyEncrypted); break;}
            case '^': {fputs("211211211", textyEncrypted); break;}
            case '_': {fputs("112221211", textyEncrypted); break;}
            case '\n': {fputs("112221222", textyEncrypted); break;}
            case '   ': {fputs("112211212", textyEncrypted); break;}
            case '\'': {fputs("111111112", textyEncrypted); break;}
            case 'ñ': {fputs("222111121", textyEncrypted); break;}
            case '[': {fputs("121111121", textyEncrypted); break;}
            case ']': {fputs("222212121", textyEncrypted); break;}
            case '\\': {fputs("222211122", textyEncrypted); break;}
                               
            default: {fputs("123456789", textyEncrypted); break;}
         }
         counter++;
      }
      std::cout << "done\n";   //Sign
      std::cout << "Closing file B...\t";   //Sign
      fclose(textyEncrypted);
      std::cout << "done\n";   //Sign
      
      std::cout << "\n\n\n\n*-----------------------*\n";
      std::cout << "*-----------------------*";
      std::cout << "\n\nEncryption completed\n\n";
      std::cout << "*-----------------------*\n";
      std::cout << "*-----------------------*\n\n\n\n";
   }
   else
   {
      std::cout << "Fail\n\n\n";
   }
}

long op()
{
   long opciones;
   std::cout << "Select an option:" << std::endl;
//   std::cout << "_____________________________________\n" << std::endl;
   std::cout << "\n";
   std::cout << "1.Encode notepad\t" << std::endl;
   std::cout << "2.Decode notepad\t" << std::endl;
//   std::cout << "\n_____________________________________" << std::endl;
   std::cin >> opciones;
   system("cls");
   return opciones;
}

y como podemos ver, se decodifica incompletamente.
Alguien sabe porque?, Gracias!

Si por ejemplo, un ejecutable te pide una contraseña y fallas 3 veces,
que el programa automaticamente se elimine o no se pueda volver a
ejecutar.

Esto es posible?
Como?

Gracias! (:

muchas gracias por las respuestas The Swash y do-while, pero creo que no me supe explicar bien

perdon do-while, me referia a qe (yo) no supe explicar bien mi pregunta; y muchas gracias!, gracias a tu explicacion aprendi algo nuevo hoy y me quedo mas que claro.

ohh que pena, ya me funciono.

quedo asi:

   

Código (cpp) [Seleccionar] Expandir

filePad = fopen("TextEncrypted.txt", "a+");
while(std::cin.get() != '\n');
std::cout << "Text:\n";
std::cin.getline(text, 50000);

Gracias!

pero de todos modos no lee el caracter =s, si pongo ese codigo y luego le digo imprime el caracter, no imprime nada =s, ya que (si no me equivoco) no leeyo nada realmente.

modifique esto en la parte de mero abajo nadamas:

parte de mero abajo:

Código (cpp) [Seleccionar] Expandir



filePad = fopen("TextEncrypted.txt", "a+");
std::cout << "Text:\n";
std::cin.getline(text, 50000);
while(std::cin.get() != '\n');
std::cout << "nice!";

std::cout << text;




codigo completo:

Código (cpp) [Seleccionar] Expandir



#include "stdafx.h"
#include <iostream>
#include <iomanip>

void encode();
int op();

int main()
{
int  resultado;

resultado = op();

switch(resultado)
{
case 1: encode();
break;
default: std::cout << "nada!";
}

system ("pause");
return 0;
}

int op()
{
       int opciones = 0;
std::cout << "Select an option:\n1.Encode\n";
std::cin >> opciones;
system("cls");
return opciones;
}

void encode()
{
int counter = 0;
FILE * filePad;
int lengthText = 0;
char text[50000];

filePad = fopen("TextEncrypted.txt", "a+");
std::cout << "Text:\n";
std::cin.getline(text, 50000);
while(std::cin.get() != '\n');
std::cout << "nice!";

std::cout << text;
}



muchas gracias por las respuestas The Swash y do-while, pero creo que no me supe explicar bien, ninguna de las 2 resolvio el problema que tengo aunque si me fueron de ayuda!

ya mejore lo de las funciones (: ya que es cierto que no ocupaba tenerla como parametro.

y el siguiente codigo si no me equivoco es solo para detener el programa hasta que des un enter.

Código (cpp) [Seleccionar] Expandir

while(cin.get() != '\n');

Hola, hay un error en funciones y no logro encontrarlo, primero que nada quiero que sepan que soy nuevo en esto de usar funciones, siempre eh hecho completamente mi programa en main y ahora estoy empezando a usar funciones.

Este codigo si corre bien, pero a la hora de poner la opcion 1, entra a la funcion "encode" y en la funcion encode, se supone que debe de preguntar el texto que se va a codificar, pero en vez de preguntarlo se lo brinca completamente.

Cabe aclarar que si lo pongo todo en main y no uso las funciones, si hace lo que tiene que hacer, pero en algun lado me equivoque con las funciones y simplemente se salta todo.

agradezco mucho la ayuda! (:

Código [Seleccionar] Expandir


#include "stdafx.h"
#include <iostream>
#include <iomanip>

void encode();
int op(int);

int main()
{
int opciones, resultado;

opciones = 0;
resultado = op(opciones);

switch(resultado)
{
case 1: encode();
break;
default: std::cout << "nada!";
}

system ("pause");
return 0;
}

int op(int opciones)
{
std::cout << "Select an option:\n1.Encode\n";
std::cin >> opciones;
system("cls");
return opciones;
}

void encode()
{
int counter = 0;
FILE * filePad;
int lengthText = 0;
char text[50000];

filePad = fopen("TextEncrypted.txt", "a+");
std::cout << "Text:\n";
std::cin.getline(text, 50000);
}


me gusta mucho!, felicidades!