C++ 解码函数的奇怪输出

我有一个函数，它用一个特定的密钥解密一个caesar加密的消息，并为输出提供正确的字母，但是在它后面有一些奇怪的黑空间

下面是函数：

#include <iostream>
#include <string.h>
#include "proj1.h"
#include <cstdlib>
using namespace std;

int main()
{

  char dec[MAXMSGLEN];


  int i = 0;

  while(i < NUMMSGS){
    char solve = SolveCipher(cipher[i], dec);


      if(solve == '\0')
        {
          cout  << "Message #" << (i + 1) << " was not intertesting. " <<endl;
        }
      else
        {
          cout << "Message #" << (i + 1) << ",Key " << solve << endl;
          cout << "\t" << dec << endl;
        }


      i++;

  }


  return 0;
}

void Decipher(char cip[], char key){

  for(int i = 0; i < MAXMSGLEN && cip[i] != '\0'; i++){
    if (cip[i] != ' '){
      cip[i] = char(cip[i] - ((key - 'A')% 26));
      if (cip[i] < 65){
        cip[i] = ((65 - cip[i])-90);

      }

    }
    else{
      cip[i] = cip[i];
    }

  }
}


char SolveCipher(const char cip[], char dec[]){

  char msg[MAXMSGLEN];
  char check[MAXMSGLEN];
  char word[MAXCRIBLEN];

  //Deciphers message with every key
  for(char i = 'A'; i <= 'Z'; i++){

    //clears msg
    memset(msg, 0, (sizeof(msg)/sizeof(msg[0])));


    //stores cip in msg
    for(int j = 0; cip[j] != '\0'; j++){
      msg[j] = cip[j];
    }

    Decipher(msg, i);
    cout<< msg <<endl;
  }
  return '\0';
}

void Decipher(char cip[], char key){

    for(int i = 0; i < MAXMSGLEN; i++){
    if(cip[i] == '\0'){
        break; // end the loop once we reached the string terminator
    }
    if (cip[i] != ' '){
      cip[i] = char(cip[i] - ((key - 'A')% 26));
      if (cip[i] < 'A'){
          cip[i] = ('Z' - ('A' - cip[i])); // <-- this is where you were getting negative values
        }
    }
  }
}

仅供参考，我需要保持参数不变。我不能把它们改成字符串或类似的东西

如果我用蛮力循环穿过黑色空间，进入文字内部

ROBO MYWO LKN XOGC DKVUSXQ DRSC KXN DRKD
QNAN LXVN KJM WNFB CJUTRWP CQRB JWM CQJC
PM▒M KWUM JIL VMEA BITSQVO BPQA IVL BPIB
OL▒L JVTL IHK ULD▒ AHSRPUN AOP▒ HUK AOHA
NK▒K IUSK HGJ TKC▒ ▒GRQOTM ▒NO▒ GTJ ▒NG▒
MJ▒J HTRJ GFI SJB▒ ▒FQPNSL ▒MN▒ FSI ▒MF▒
LI▒I GSQI FEH RIA▒ ▒EPOMRK ▒LM▒ ERH ▒LE▒
KH▒H FRPH EDG QH▒▒ ▒DONLQJ ▒KL▒ DQG ▒KD▒
JG▒G EQOG DCF PG▒▒ ▒CNMKPI ▒JK▒ CPF ▒JC▒
IF▒F DPNF CBE OF▒▒ ▒BMLJOH ▒IJ▒ BOE ▒IB▒
HE▒E COME BAD NE▒▒ ▒ALKING ▒HI▒ AND ▒HA▒
GD▒D BNLD A▒C MD▒▒ ▒▒KJHMF ▒GH▒ ▒MC ▒G▒▒
FC▒C AMKC ▒▒B LC▒▒ ▒▒JIGLE ▒FG▒ ▒LB ▒F▒▒
EB▒B ▒LJB ▒▒A KB▒▒ ▒▒IHFKD ▒EF▒ ▒KA ▒E▒▒
DA▒A ▒KIA ▒▒▒ JA▒▒ ▒▒HGEJC ▒DE▒ ▒J▒ ▒D▒▒
C▒▒▒ ▒JH▒ ▒▒▒ I▒▒▒ ▒▒GFDIB ▒CD▒ ▒I▒ ▒C▒▒
B▒▒▒ ▒IG▒ ▒▒▒ H▒▒▒ ▒▒FECHA ▒BC▒ ▒H▒ ▒B▒▒
A▒▒▒ ▒HF▒ ▒▒▒ G▒▒▒ ▒▒EDBG▒ ▒AB▒ ▒G▒ ▒A▒▒
▒▒▒▒ ▒GE▒ ▒▒▒ F▒▒▒ ▒▒DCAF▒ ▒▒A▒ ▒F▒ ▒▒▒▒
▒▒▒▒ ▒FD▒ ▒▒▒ E▒▒▒ ▒▒CB▒E▒ ▒▒▒▒ ▒E▒ ▒▒▒▒
▒▒▒▒ ▒EC▒ ▒▒▒ D▒▒▒ ▒▒BA▒D▒ ▒▒▒▒ ▒D▒ ▒▒▒▒
▒▒▒▒ ▒DB▒ ▒▒▒ C▒▒▒ ▒▒A▒▒C▒ ▒▒▒▒ ▒C▒ ▒▒▒▒
▒▒▒▒ ▒CA▒ ▒▒▒ B▒▒▒ ▒▒▒▒▒B▒ ▒▒▒▒ ▒B▒ ▒▒▒▒
▒▒▒▒ ▒B▒▒ ▒▒▒ A▒▒▒ ▒▒▒▒▒A▒ ▒▒▒▒ ▒A▒ ▒▒▒▒
▒▒▒▒ ▒A▒▒ ▒▒▒ ▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒ ▒▒▒ ▒▒▒▒
▒▒▒▒ ▒▒▒▒ ▒▒▒ ▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒ ▒▒▒ ▒▒▒▒

---

对此有什么想法吗？

您的问题是将字符串中的值“一直”更改为

MAXMSGLEN

。现在要做的是解密消息的主体（比如10个字符），不要停止，而是继续，更新超出范围的值

一旦您看到“字符串结束”空终止符

“\0

，修复程序将停止：

void Decipher(char cip[], char key){

    for(int i = 0; i < MAXMSGLEN && cip[i] != '\0'; i++){
    if (cip[i] != ' '){
      cip[i] = char(cip[i] - ((key - 'A')% 26));
      if (cip[i] < 65){
          cip[i] = ((65 - cip[i])-90);
        }
    }
  }
}

---

只需将字符串作为

字符串传递即可：

void Decipher(std::string& cip, char key) {
  for (char& ch : cip) {
    if (ch != ' ') {
      ch = char(ch - ((key - 'A') % 26));
      if (ch < 65) {
        ch = ((65 - ch)-90);
      }
    }
  }
}

void解密（std:：string&cip，char键）{
用于（字符和通道：cip）{
如果（ch！=''）{
ch=char（ch-（（键-'A'）%26））；
如果（ch<65）{
ch=（（65-ch）-90）；
}
}
}
}

通过这种方式，还可以传递有关其长度的信息，您只需在字符之间执行基于范围的循环。
您正在破译不属于消息一部分的字符@DavidSchwartz所以用sizeof（cip）替换MAXMSGLEN？不，因为这也不是消息的大小。我建议将消息的长度作为参数传递。或者它有一个终止字符？为什么不使用
std:：string
或类似的东西？（如果不清楚
sizeof（cip）
为什么是错误的，那么关于这一点：既然
cip
可以容纳短字符串或长字符串，它的大小不能是字符串的大小。）您可以复制粘贴完整的（可构建的）吗代码样本？当我循环所有的键（蛮力），这些奇怪的黑色事物出现在短语的中间。我把它加在问题上，这样你就能明白了
void Decipher(char cip[], char key){

    for(int i = 0; i < MAXMSGLEN; i++){
    if(cip[i] == '\0'){
        break; // end the loop once we reached the string terminator
    }
    if (cip[i] != ' '){
      cip[i] = char(cip[i] - ((key - 'A')% 26));
      if (cip[i] < 'A'){
          cip[i] = ('Z' - ('A' - cip[i])); // <-- this is where you were getting negative values
        }
    }
  }
}

void Decipher(std::string& cip, char key) {
  for (char& ch : cip) {
    if (ch != ' ') {
      ch = char(ch - ((key - 'A') % 26));
      if (ch < 65) {
        ch = ((65 - ch)-90);
      }
    }
  }
}