Foros Club Delphi - No me compila una clase

Foros Club Delphi (https://www.clubdelphi.com/foros/index.php)

- C++ Builder (https://www.clubdelphi.com/foros/forumdisplay.php?f=13)

- - No me compila una clase (https://www.clubdelphi.com/foros/showthread.php?t=89239)

No me compila una clase

Hola amigos, vi un articulo interesante sobre el cifrado Vigenese y venia con el codigo y tenia varias cosas con las que no me podia compilar asi que las he reparado pero me sigue sin compilar fundamentalmente por dos errores y no se como solucionarlos.

Cita:

[C++ Warning] Unit1.cpp(21): W8058 Cannot create pre-compiled header: header incomplete
[C++ Error] Unit1.cpp(21): E2111 Type 'Vigenere' may not be defined here
[C++ Error] Unit1.cpp(21): E2136 Constructor cannot have a return type specification
[C++ Warning] Unit1.cpp(44): W8012 Comparing signed and unsigned values
[C++ Warning] Unit1.cpp(51): W8012 Comparing signed and unsigned values
[C++ Warning] Unit1.cpp(58): W8012 Comparing signed and unsigned values
[C++ Warning] Unit1.cpp(80): W8012 Comparing signed and unsigned values
[C++ Warning] Unit1.cpp(89): W8012 Comparing signed and unsigned values
[C++ Warning] Unit1.cpp(106): W8012 Comparing signed and unsigned values
[C++ Error] Unit1.cpp(112): E2285 Could not find a match for 'string::append(char)'

Son los errores del principio de la lista y el del final de la lista ya que el resto son Warnings que me dicen que estoy comparando enteros con signo y sin signo y no es importante en este caso.
El codigo lo tengo acomodado ahora mismo asi:
Unit1.cpp:

Código PHP:


		
			
/************************************************
*  Nombre : Vigenere.cpp                        *
*                                               *
*  Cifrado de cesar de sustitución multiple     *
*  por medio de sumas y restas del alfabeto     *
*                                               *
*  Fulapol                                      *
*  [email protected]                            *
*  my.opera.com/fulapol                         *
*                                               *
************************************************/

/************************************************
*                                               *
*  El Constructor que debe recibir la cadena a  *
*  tratar y la cadena semilla                   *
*                                               *
************************************************/
#include "Unit1.h"

Vigenere::Vigenere(string orig, string sem){
   letras = "abcdefghijklmnopqrstuvwxyz";
   this->texto = limpiar(orig);
   this->semilla = limpiar(sem);
}

Vigenere::~Vigenere(){

}
/************************************************
*                                               *
*  El metodo cifrar, que regresa una cadena de  *
*  texto que solo despues de ser cifrada        *
*                                               *
************************************************/

string Vigenere::cifrar(){
   string final;
   int i, movimiento, rotacion, total;
   size_t pos, pos2;
   //Las variables serviran para registrar la posicion
   //de las letras y calcular la semilla

   for(i=0, rotacion=0; i < texto.length(); i++, rotacion++){
      pos = letras.find(texto.at(i));
      pos2 = letras.find(semilla.at(rotacion));
      total = ((int)(pos+pos2))%letras.length();
      //El total que marca la posicion de la letra y la
      //semilla sumadas

      if(total > letras.length())
         movimiento = total - letras.length();
      else
         movimiento = total;
      //Para asegurarnos que esta dentro del rango

      final.append(letras, movimiento, 1);
      if(rotacion == semilla.length())
         rotacion = 0;
      //Si se acaba la semilla, regresar al principio
   }
   return final;
}

/************************************************
*                                               *
*  El metodo descifrar, que regresa una cadena  *
*  de texto que solo despues de ser descifrada  *
*                                               *
************************************************/

string Vigenere::descifrar(){
   //La funcion es exactamente la misma que en el metodo
   //cifrar, solo que aqui las posiciones se restan para
   //eliminar la semilla del texto

   string final;
   int i, movimiento, rotacion, total;
   size_t pos, pos2;
   for(i=0, rotacion=0; i<texto.length(); i++, rotacion++){
      pos = letras.find(texto.at(i));
      pos2 = letras.find(semilla.at(rotacion));
      total = ((int)(pos - pos2)) % letras.length();
      if(total < 0)
         movimiento = total + letras.length();
      else
         movimiento = total;
      final.append(letras, movimiento, 1);
      if(rotacion == semilla.length())
         rotacion = 0;
   }
   return final;
}

/************************************************
*                                               *
*  El metodo limpiar, que regresa una cadena de *
*  texto que solo contiene los caracteres       *
*  soportados por la clase                      *
*                                               *
************************************************/

string Vigenere::limpiar(string cadena){
   int i;
   string final;
   for(i=0; i < cadena.length(); i++){
      if(cadena.at(i) > 64 && cadena.at(i) < 91)
         cadena.at(i) += 32;
      //Pasamos el caracter a minusculas

      if(letras.find(cadena.at(i)) != -1)
         final.append(cadena.at(i));
      //Agregamos a la cadena final el caracter
      //si se encuentra en la variable letras
   }
   return final;
}

Unit1.h:

Código PHP:


		
			
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <cstring.h>

class Vigenere{
   private:
      string texto,semilla,letras;
      string limpiar(string cadena);
      //Las variables son privadas, el metodo limpiar
      //es privada ya que solo lo utilizan los otros
      //metodos para limpiar la entrada

   public:
      Vigenere(string orig, string sem);
      ~Vigenere();
      string cifrar();
      string descifrar();
      //Esto es publico porque es la unica forma de
      //accesar a los datos de la clase
}
//---------------------------------------------------------------------------
#endif

Me di cuenta que me faltaba el ; detras del corchete de cierre del .h de la clase y por eso eran los primeros errores pero ahora me falta el ultimo y no se como solucionarlo.

Lo he solucionado con esta linea de codigo:

Código PHP:


		
			
final.append(&cadena.at(i),1);

Eso funciona correctamente aunque quizas no sea la mejor manera y me gustaria saber como hacerlo usando append y de la manera mas correcta posible.

Ahora he modificado el codigo un poco y sobre todo he añadido mas caracteres a la mascara de caracteres válidos y ya no funciona correctamente. Tengo esto:
Main.cpp:

Código PHP:


		
			
//---------------------------------------------------------------------------
#include <iostream>
#include "Unit1.h"
//---------------------------------------------------------------------------

int main()
{
   string cadena = "Hola Mundo, como te va.";
   string semilla = "aguml";

   Vigenere *vig = new Vigenere;
   string cifrada = vig->cifrar(cadena, semilla);
   std::cout << cifrada << std::endl;

   string descifrada = vig->descifrar(cifrada, semilla);
   std::cout << descifrada << std::endl;
   delete vig;
   std::cin.get();

   return 0;
}

Unit1.cpp:

Código PHP:


		
			
/************************************************
*  Nombre : Vigenere.cpp                        *
*                                               *
*  Cifrado de cesar de sustitución multiple     *
*  por medio de sumas y restas del alfabeto     *
*                                               *
*  Fulapol                                      *
*  [email protected]                            *
*  my.opera.com/fulapol                         *
*                                               *
************************************************/

/************************************************
*                                               *
*  El Constructor que debe recibir la cadena a  *
*  tratar y la cadena semilla                   *
*                                               *
************************************************/
#include "Unit1.h"

Vigenere::Vigenere(){
   letras = "abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZáéíóúÁÉÍÓÚüÜ1234567890¿?¡!,;.:-_ \"<>()=+*/&%$#@";
}

Vigenere::~Vigenere(){

}
/************************************************
*                                               *
*  El metodo cifrar, que regresa una cadena de  *
*  texto que solo despues de ser cifrada        *
*                                               *
************************************************/

string Vigenere::cifrar(string orig, string sem){
   string final;
   int i, movimiento, rotacion, total;
   size_t pos, pos2;
   //Las variables serviran para registrar la posicion
   //de las letras y calcular la semilla

   this->texto = limpiar(orig);
   this->semilla = limpiar(sem);

   for(i=0, rotacion=0; i < texto.length(); i++, rotacion++){
      pos = letras.find(texto.at(i));
      pos2 = letras.find(semilla.at(rotacion));
      total = ((int)(pos+pos2))%letras.length();
      //El total que marca la posicion de la letra y la
      //semilla sumadas

      if(total > letras.length())
         movimiento = total - letras.length();
      else
         movimiento = total;
      //Para asegurarnos que esta dentro del rango

      final.append(letras, movimiento, 1);
      if(rotacion == semilla.length() - 1)
         rotacion = 0;
      //Si se acaba la semilla, regresar al principio
   }
   return final;
}

/************************************************
*                                               *
*  El metodo descifrar, que regresa una cadena  *
*  de texto que solo despues de ser descifrada  *
*                                               *
************************************************/

string Vigenere::descifrar(string orig, string sem){
   //La funcion es exactamente la misma que en el metodo
   //cifrar, solo que aqui las posiciones se restan para
   //eliminar la semilla del texto

   string final;
   int i, movimiento, rotacion, total;
   size_t pos, pos2;

   this->texto = limpiar(orig);
   this->semilla = limpiar(sem);
   
   for(i=0, rotacion=0; i<texto.length(); i++, rotacion++){
      pos = letras.find(texto.at(i));
      pos2 = letras.find(semilla.at(rotacion));
      total = ((int)(pos - pos2)) % letras.length();
      if(total < 0)
         movimiento = total + letras.length();
      else
         movimiento = total;
      final.append(letras, movimiento, 1);
      if(rotacion == semilla.length() - 1)
         rotacion = 0;
   }
   return final;
}

/************************************************
*                                               *
*  El metodo limpiar, que regresa una cadena de *
*  texto que solo contiene los caracteres       *
*  soportados por la clase                      *
*                                               *
************************************************/

string Vigenere::limpiar(string cadena){
   int i;
   string final;
   for(i=0; i < cadena.length(); i++){
      if(letras.find(cadena.at(i)) != -1)
         final.append(&cadena.at(i),1);
      //Agregamos a la cadena final el caracter
      //si se encuentra en la variable letras
   }
   return final;
}

Unit1.h:

Código PHP:


		
			
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <cstring.h>

class Vigenere{
   private:
      string texto,semilla,letras;
      string limpiar(string cadena);
      //Las variables son privadas, el metodo limpiar
      //es privada ya que solo lo utilizan los otros
      //metodos para limpiar la entrada

   public:
      Vigenere();
      ~Vigenere();
      string cifrar(string orig, string sem);
      string descifrar(string orig, string sem);
      //Esto es publico porque es la unica forma de
      //accesar a los datos de la clase
};
//---------------------------------------------------------------------------
#endif

¿Como la pongo correctamente la máscara?

Prueba así:

Código PHP:


		
			
string Vigenere::cifrar(string orig, string sem){
   string final;
   int i, rotacion, total;
   int pos, pos2;
   //Las variables serviran para registrar la posicion
   //de las letras y calcular la semilla

   this->texto = limpiar(orig);
   this->semilla = limpiar(sem);

   for(i=0; i < texto.length(); i++){
      rotacion = i%semilla.length();
      pos = letras.find(texto.at(i));
      pos2 = letras.find(semilla.at(rotacion));
      total = (pos+pos2)%letras.length();
      //El total que marca la posicion de la letra y la
      //semilla sumadas

      final.append(letras, total, 1);
   }
   return final;
}


string Vigenere::descifrar(string orig, string sem){
   //La funcion es exactamente la misma que en el metodo
   //cifrar, solo que aqui las posiciones se restan para
   //eliminar la semilla del texto

   string final;
   int i, rotacion, total;
   int pos, pos2;

   this->texto = limpiar(orig);
   this->semilla = limpiar(sem);

   for(i=0; i<texto.length(); i++){
      rotacion = i%semilla.length();
      pos = letras.find(texto.at(i));
      pos2 = letras.find(semilla.at(rotacion));
      total = (letras.length() + pos - pos2) % letras.length();

      final.append(letras, total, 1);
   }
   return final;
}

Saludos.

PD/ Cuidado con la salida por consola, algunos caracteres pueden salir cambiados.

Si si, lo de los caracteres lo se pero es simplemente para hacer una prueba. Si fuese a leer o escribir en un archivo usando fread y fwrite no pasaria.
La verdad es que estudiando tu codigo y el que yo tenia veo que el que yo tenia tenia condicionales que eran redundantes pero no veo cual era el problema ya que haciendo las cuentas en ambos creo que funcionan igual. ¿me puedes explicar donde estaba el fallo exactamente para que diera resultados no validos?

Cita:

Empezado por aguml (Mensaje 498260)

¿me puedes explicar donde estaba el fallo exactamente para que diera resultados no validos?

La codificación era correcta pero no la descodificación. El problema estaba aquí:

Código PHP:


		
			
total = (pos - pos2) % letras.length();

Si se sobrepasó la longitud de letras al codificar, (pos-pos2) no elimina la semilla correctamente y la resta será negativa. Dado que pos1+pos2 nunca puede ser mayor que 2*letras.length(), la solución es esta:

Código PHP:


		
			
total = (letras.length() + pos - pos2) % letras.length();

Saludos.

Ahora estoy intentando hacer lo mismo con un archivo de texto plano y hago esto:

Código PHP:


		
			
//---------------------------------------------------------------------------
#include <iostream>
#include <fstream.h>
#include "Vigenere.h"
//---------------------------------------------------------------------------

using namespace std;

int main()
{
   ifstream origen;
   ofstream salida;
   string semilla,cifrada,descifrada;
   char *cadena;

   semilla = "aguml";
   
   //Parte que encripta el archivo
   origen.open("Main.h");

   if(origen.good()){
      origen.seekg(0,origen.end);
      int length = origen.tellg();
      origen.seekg(0,origen.beg);
      cadena = new char[length+1];
      Vigenere *vig = new Vigenere;
      salida.open("Encriptado.txt");

      if(salida.good()){
         origen.read(cadena,length);
         cadena[length]='\0';
         salida.write(vig->cifrar(cadena, semilla).c_str(),length);
         salida.close();
      }
      delete vig;
      delete(cadena);
      origen.close();
   }

   //Parte que desencripta el archivo
   origen.open("Encriptado.txt");

   if(origen.good()){
      origen.seekg(0,origen.end);
      int length = origen.tellg();
      origen.seekg(0,origen.beg);
      cadena = new char[length+1];
      Vigenere *vig = new Vigenere;
      salida.open("Desencriptado.txt");

      if(salida.good()){
         origen.read(cadena,length);
         cadena[length]='\0';
         salida.write(vig->descifrar(cadena, semilla).c_str(),length);
         salida.close();
      }
      delete vig;
      delete(cadena);
      origen.close();
   }
   return 0;
}

Tengo dos problemas.
1. El archivo se abre la primera vez pero despues de cerrarlo intento abrirlo una segunda vez y parece que hay algun problema porque no entra en la parte de desencriptar.
2. Me añade basura al final del archivo y eso que pongo el caracter de fin de cadena al final de la cadena.
¿puedes ayudarme?

Pues al final lo he solucionado abriendolo de forma binaria. No se porque si no es asi falla y me gustaria saberlo.

Cita:

Empezado por aguml (Mensaje 498269)

Pues al final lo he solucionado abriendolo de forma binaria. No se porque si no es asi falla y me gustaria saberlo.

No hice pruebas con tu código pero recuerda que en modo texto las líneas acaban en CRLF. Es la gran diferencia entre los dos modos de abrir un archivo. Cuando el texto está codificado siempre es preferible el modo binario.

Personalmente no me gustan los stream de C++ y los uso en muy contadas ocasiones. Incluso he detectado bugs en en mismo código fuente de Builder C++ 5 que arreglé en su momento con cambios en el mismo.

Saludos.

Asi he dejado el codigo:
Main.cpp:

Código PHP:


		
			
//---------------------------------------------------------------------------
#include <iostream>
#include <fstream.h>
#include "Vigenere.h"
//---------------------------------------------------------------------------

using namespace std;

void InfoUso();
void Desencriptar(char *nameFileIn, char *semilla, char *nameFileOut);
void Encriptar(char *nameFileIn, char *semilla, char *nameFileOut);

int main(int argc, char *argv[])
{
   if(argc == 5){
      if(argv[1][0] == 'e' && argv[1][1] == '\0'){
         Encriptar(argv[2],argv[3],argv[4]);
         cout << "Operacion finalizada." << endl;
      }else if(argv[1][0] == 'd' && argv[1][1] == '\0'){
         Desencriptar(argv[2],argv[3],argv[4]);
         cout << "Operacion finalizada." << endl;
      }else{
         cout << "Opcion no valida." << endl;
         InfoUso();
      }
   }else if(argc<5){
      cout << "Faltan argumentos." << endl;
      InfoUso();
   }else{
      cout << "Sobran argumentos." << endl;
      InfoUso();
   }
   return 0;
}

void InfoUso()
{
   cout << "Vigenere.exe [operacion] [archivo] [semilla]" << endl;
   cout << "operacion: 'd' desencriptar. 'e' encriptar." << endl;
   cout << "archivo: ruta completa del archivo o solo el nombre si esta junto a este ejecutable." << endl;
   cout << "semilla: la cadena que va a ser usada como semilla para encriptar/desencriptar el archivo." << endl;
}

//Funcion que encripta el archivo
void Encriptar(char *nameFileIn, char *semilla, char *nameFileOut)
{
   ifstream origen;
   ofstream salida;
   char *cadena;

   origen.open(nameFileIn,ios::binary);

   if(origen.good()){
      origen.seekg(0,ios::end);
      int length = origen.tellg();
      origen.seekg(0,ios::beg);
      cadena = new char[length+1];
      Vigenere *vig = new Vigenere;
      salida.open(nameFileOut,ios::binary | ios::trunc);

      if(salida.good()){
         origen.read(cadena,length);
         cadena[length]='\0';
         salida.write(vig->cifrar(cadena, semilla).c_str(),length);
         salida.close();
      }
      delete vig;
      delete(cadena);
      origen.close();
   }
}

//Funcion que desencripta el archivo
void Desencriptar(char *nameFileIn, char *semilla, char *nameFileOut)
{
   ifstream origen;
   ofstream salida;
   char *cadena;

   origen.open(nameFileIn,ios::binary);

   if(origen.good()){
      origen.seekg(0,ios::end);
      int length = origen.tellg();
      origen.seekg(0,ios::beg);
      cadena = new char[length+1];
      Vigenere *vig = new Vigenere;
      salida.open(nameFileOut,ios::binary | ios::trunc);

      if(salida.good()){
         origen.read(cadena,length);
         cadena[length]='\0';
         salida.write(vig->descifrar(cadena, semilla).c_str(),length);
         salida.close();
      }
      delete vig;
      delete(cadena);
      origen.close();
   }
}

Vigenere.h:

Código PHP:


		
			
//---------------------------------------------------------------------------
#ifndef VigenereH
#define VigenereH
//---------------------------------------------------------------------------
#include <cstring.h>

class Vigenere{
   private:
      string texto,semilla,caracteresValidos;
      string limpiar(string cadena);
      //Las variables son privadas, el metodo limpiar
      //es privada ya que solo lo utilizan los otros
      //metodos para limpiar la entrada

   public:
      Vigenere();
      ~Vigenere();
      string cifrar(string orig, string sem);
      string descifrar(string orig, string sem);
      //Esto es publico porque es la unica forma de
      //accesar a los datos de la clase
};
//---------------------------------------------------------------------------
#endif

Vigenere.h:

Código PHP:


		
			
/************************************************
*  Nombre : Vigenere.cpp                        *
*                                               *
*  Cifrado de cesar de sustitución multiple     *
*  por medio de sumas y restas del alfabeto     *
*                                               *
*  Fulapol                                      *
*  [email protected]                            *
*  my.opera.com/fulapol                         *
*                                               *
************************************************/

/************************************************
*                                               *
*  El Constructor que debe recibir la cadena a  *
*  tratar y la cadena semilla                   *
*                                               *
************************************************/
#include "Vigenere.h"

Vigenere::Vigenere(){
   caracteresValidos = "abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZáéíóúÁÉÍÓÚüÜ1234567890¿?¡!,;.:-_ \"\t\n\r\\<>(){}[]^çÇ=+*/&%$#@";
}

Vigenere::~Vigenere(){

}
/************************************************
*                                               *
*  El metodo cifrar, que regresa una cadena de  *
*  texto que solo despues de ser cifrada        *
*                                               *
************************************************/

string Vigenere::cifrar(string orig, string sem){
   string final;
   unsigned int i, rotacion, total;
   int pos, pos2;
   //Las variables serviran para registrar la posicion
   //de las letras y calcular la semilla

   this->texto = limpiar(orig);
   this->semilla = limpiar(sem);

   for(i=0; i < texto.length(); i++){
      rotacion = i%semilla.length();
      pos = caracteresValidos.find(texto.at(i));
      pos2 = caracteresValidos.find(semilla.at(rotacion));
      total = (pos+pos2)%caracteresValidos.length();
      //El total que marca la posicion de la letra y la
      //semilla sumadas

      final.append(caracteresValidos, total, 1);
   }
   return final;
}

/************************************************
*                                               *
*  El metodo descifrar, que regresa una cadena  *
*  de texto que solo despues de ser descifrada  *
*                                               *
************************************************/

string Vigenere::descifrar(string orig, string sem){
   //La funcion es exactamente la misma que en el metodo
   //cifrar, solo que aqui las posiciones se restan para
   //eliminar la semilla del texto

   string final;
   unsigned int i, rotacion, total;
   int pos, pos2;

   this->texto = limpiar(orig);
   this->semilla = limpiar(sem);

   for(i=0; i<texto.length(); i++){
      rotacion = i%semilla.length();
      pos = caracteresValidos.find(texto.at(i));
      pos2 = caracteresValidos.find(semilla.at(rotacion));
      total = (caracteresValidos.length() + pos - pos2) % caracteresValidos.length();

      final.append(caracteresValidos, total, 1);
   }
   return final;
}

/************************************************
*                                               *
*  El metodo limpiar, que regresa una cadena de *
*  texto que solo contiene los caracteres       *
*  soportados por la clase                      *
*                                               *
************************************************/

string Vigenere::limpiar(string cadena){
   unsigned int i;
   string final;
   for(i=0; i < cadena.length(); i++){
      if(caracteresValidos.find(cadena.at(i)) != -1)
         final.append(&cadena.at(i),1);
      //Agregamos a la cadena final el caracter
      //si se encuentra en la variable letras
   }
   return final;
}

Ahora tengo otra duda. Si en vez de usar ese cifrado quisiese usar uno de desplazamientos, o sea tener un array con los caracteres válidos y a la función le meto una cadena y un valor de desplazamiento como por ejemplo encriptar ("hola",3). Cada caracter se desplazaría 3 posiciones en el array de letras con lo que quedaría "krñd". ¿como seria eso para cifrar y descifrar? Llevo toda la tarde y no doy con la forma correcta para que no desborde y de un resultado correcto.
He visto que ese cifrado se llama Cesar y vi esto: https://es.m.wikipedia.org/wiki/Cifrado_César
El problema con esas fórmulas es que imaginen que la letra es la z y el desplazamiento es 0:
Salida=(27+0)%27=0
Sí no hay desplazamiento debería dar 27 ¿no?

Cita:

Empezado por aguml (Mensaje 498351)

El problema con esas fórmulas es que imaginen que la letra es la z y el desplazamiento es 0:
Salida=(27+0)%27=0
Sí no hay desplazamiento debería dar 27 ¿no?

El problema es de concepto. La tabla de caracteres empieza en elemento 0, por lo que el último carácter es el 26 y no el 27.

Saludos.

Porque harias un desplazamineto a cero

mira este codigo

Código:

#include <iostream>

using namespace std;





string cifrarCesar(const string cadena, const int rotacion){

   string sFinal=cadena;

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

        sFinal[i]=char(int(cadena[i])+(rotacion %256));

   }

   return sFinal;

}

string descifrarCesar(const string cadena, const int rotacion){

   string sFinal=cadena;

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

        sFinal[i]=char(int(cadena[i])-(rotacion %256));

   }

   return sFinal;

}





int main()

{

    string cadena=cifrarCesar("hola mundo",3);

    cout<<cadena<<endl;

    string descifrada=descifrarCesar(cadena,3);

    cout<<descifrada<<endl;

    return 0;

}

Cita:

Empezado por BDWONG (Mensaje 498353)

Porque harias un desplazamineto a cero

Al menos en teoría debe funcionar para cualquier desplazamiento sin preguntar si es o no cero, que es lo que se plantea aguml. La explicación que dí y que aplicas a tu código: el primer carácter es el 0 y el último 255, siendo en total 256.

Salidos.

Después de analizar mi prueba creo que esto funciona correctamente:
Encriptar:

Código PHP:


		
			
int largo,posInicial,posFinal;

char Mensaje []="HOLA";

char Letras []="ABCDEFGHIJKLMNÑOPQRSTUVWXYZ";

int numero=5;

 

largo = strlen (Letras);

posInicial = strchr (Letras,Mensaje [i]);

posFinal = (largo + posInicial + numero) % largo;

Mensaje [i]=Letras [posFinal];

Desecriptar:

Código PHP:


		
			
int largo,posInicial,posFinal;

char Mensaje []="MTPF";

char Letras []="ABCDEFGHIJKLMNÑOPQRSTUVWXYZ";

int numero=5;

 

largo = strlen (Letras);

posInicial = strchr (Letras,Mensaje [i]);

posFinal = (largo + posInicial - numero) % largo;

Mensaje [i]=Letras [posFinal];

Largo da 27 mientras que el máximo de pos es 26. El fallo lo tenia porque a largo le quitaba 1.