c - 与 C 赋值堆叠-6ren

c - 与 C 赋值堆叠

转载作者：行者123 更新时间：2023-11-30 15:56:59

我必须编写一个函数int bit_to_ascii(const char input[], char output[]);，它从字符二进制代码数组中读取并翻译它。我已经这么做了。

当我在家用计算机上使用 Code::Blocks 时，一切正常。但是，当我将代码放在必须保留程序标记的服务器上时，它正在编译，但在程序的第一步之后给了我一个段错误。我能有什么错呢？ Code::Blocks 中的编译器和服务器上的编译器有什么区别？

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define LINES 5

/* assignment #1 function prototype */
int bit_to_ascii(const char input[], char output[]);

int main( ) {

const char *core_data[ ] = {
"0", /* should insert the null byte '\0' only */

"01010111 This sequence contains the letter 'W'       " /*  87 = 'W' */
"      r5 0 #! 1 1 gP 0 f66-:] 0 [ } 1 v4t^ 0 1 n>?:77" /* 101 = 'e' */
" junk ^*@&#^% 0110  more junk }{r;,<> 1100         2x" /* 108 = 'l' */
"                  0    1       1     0 0          011" /*  99 = 'c' */
"0  ^%jh  1 ]{) OVR 1 - 0 _! 9 + 1  118Y z(x pM1      " /* 111 = 'o' */
"This next group of 8 should be SKP skipped! 11111111 " /* skipped */
"*&^! 0  1  1  0 1     1 0     128673kjshd:L<    2938 " /* 109 = 'm' */
"      r5 0 #! 1 1 gP 0 f66-:] 0 [ } 1 v4t^ 0 1 n>?:77" /* 101 = 'e' */
"#!/bin/bash 00  1 00 00 0 g^b-ps 6@&^%               " /*  32 = ' ' */
"01010100 This sequence contains the letter 'T'       " /*  84 = 'T' */
"0  ^%jh  1 ]{) OVR 1 - 0 _! 9 + 1  118Y z(x pM1      " /* 111 = 'o' */
"#!/bin/bash 00  1 00 00 0 g^b-ps 6@&^%               " /*  32 = ' ' */
"---repeat--->0 1 0 0 1 1 1 1<------------RPT2--------" /*  79 = 'O' */
"0 1 0 1 0bbavac9872962  000&*************************" /*  80 = 'P' */
"a0b0c1d1e0f0g1h0ijklmnopqrstuvwxyz*******************" /*  50 = '2' */
"00fg333                                110100>>>>>>>>" /*  52 = '4' */
"00fg333                                110100>>>>>>>>" /*  52 = '4' */
"                     0000                            ",/*  0 = '\0' */

"00011110 This char should not be inserted!           " /*  30 cntrl */
" 00011111 This char should not be inserted!          " /*  31 cntrl */
"  00100000                                           " /*  32 = ' ' */
"   00100001                                          " /*  33 = '!' */
"    00100010                                         " /*  34 = '"' */
"     00100011                                        " /*  35 = '#' */
"      00100100                                       " /*  36 = '$' */
"       00100101                                      " /*  37 = '%' */
"        00100110                                     " /*  38 = '&' */
"         00100111                                    " /*  39 = ''' */
"          00101000                                   " /*  40 = '(' */
"           00101001                                  " /*  41 = ')' */
"            00101010                                 " /*  42 = '*' */
"             00101011                                " /*  43 = '+' */
"              00101100                               " /*  44 = ',' */
"               00101101                              " /*  45 = '-' */
"                00101110                             " /*  46 = '.' */
"                 00101111                            " /*  47 = '/' */
"                  00110000                           " /*  48 = '0' */
"                   00110001                          " /*  49 = '1' */
"                    00110010                         " /*  50 = '2' */
"                     00110011                        " /*  51 = '3' */
"                      00110100                       " /*  52 = '4' */
"                       00110101                      " /*  53 = '5' */
"                        00110110                     " /*  54 = '6' */
"                         00110111                    " /*  55 = '7' */
"                          00111000                   " /*  56 = '8' */
"                           00111001                  " /*  57 = '9' */
"                            00111010                 " /*  58 = ':' */
"                             00111011                " /*  59 = ';' */
"                              00111100               " /*  60 = '<' */
"                               00111101              " /*  61 = '=' */
"                                00111110             " /*  62 = '>' */
"                                 00111111            " /*  63 = '?' */
"                                  01000000           " /*  64 = '@' */
"                                   00000000          ",/*   0 = '\0'*/

"                                    01000001         " /*  65 = 'A' */
"                                     01000010        " /*  66 = 'B' */
"                                      01000011       " /*  67 = 'C' */
"                                       01000100      " /*  68 = 'D' */
"                                        01000101     " /*  69 = 'E' */
"                                         01000110    " /*  70 = 'F' */
"                                          01000111   " /*  71 = 'G' */
"                                           01001000  " /*  72 = 'H' */
"                                            01001001 " /*  73 = 'I' */
"                                             01001010" /*  74 = 'J' */
"                                            01001011 " /*  75 = 'K' */
"                                           01001100  " /*  76 = 'L' */
"                                          01001101   " /*  77 = 'M' */
"                                         01001110    " /*  78 = 'N' */
"                                        01001111     " /*  79 = 'O' */
"                                       01010000      " /*  80 = 'P' */
"                                      01010001       " /*  81 = 'Q' */
"                                     01010010        " /*  82 = 'R' */
"                                    01010011         " /*  83 = 'S' */
"                                   01010100          " /*  84 = 'T' */
"                                  01010101           " /*  85 = 'U' */
"                                 01010110            " /*  86 = 'V' */
"                                01010111             " /*  87 = 'W' */
"                               01011000              " /*  88 = 'X' */
"                              01011001               " /*  89 = 'Y' */
"                             01011010                " /*  90 = 'Z' */
"                            01011011                 " /*  91 = '[' */
"                           01011100                  " /*  92 = '/' */
"                          01011101                   " /*  93 = ']' */
"                         01011110                    " /*  94 = '^' */
"                        01011111                     " /*  95 = '_' */
"                       01100000                      " /*  96 = '`' */
"                      00000000                       ",/*   0 = '\0'*/

"                     01100001                        " /*  97 = 'a' */
"                    01100010                         " /*  98 = 'b' */
"                   01100011                          " /*  99 = 'c' */
"                  01100100                           " /* 100 = 'd' */
"                 01100101                            " /* 101 = 'e' */
"                01100110                             " /* 102 = 'f' */
"               01100111                              " /* 103 = 'g' */
"              01101000                               " /* 104 = 'h' */
"             01101001                                " /* 105 = 'i' */
"            01101010                                 " /* 106 = 'j' */
"           01101011                                  " /* 107 = 'k' */
"          01101100                                   " /* 108 = 'l' */
"         01101101                                    " /* 109 = 'm' */
"        01101110                                     " /* 110 = 'n' */
"       01101111                                      " /* 111 = 'o' */
"      01110000                                       " /* 112 = 'p' */
"     01110001                                        " /* 113 = 'q' */
"    01110010                                         " /* 114 = 'r' */
"   01110011                                          " /* 115 = 's' */
"  01110100                                           " /* 116 = 't' */
" 01110101                                            " /* 117 = 'u' */
"01110110                                             " /* 118 = 'v' */
" 01110111                                            " /* 119 = 'w' */
"  01111000                                           " /* 120 = 'x' */
"   01111001                                          " /* 121 = 'y' */
"    01111010                                         " /* 122 = 'z' */
"     01111011                                        " /* 123 = '{' */
"      011111RPT10                                    " /* 124 = '|' */
"       01111101                                      " /* 125 = '}' */
"        00000000                                     " /*   0 = '\0'*/
};

char phrase[41];
char correct[LINES][41] = {
  "",
  "Welcome To OOP244",
  " !\"#$%&'()*+,-./0123456789:;<=>?@",
  "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`",
  "abcdefghijklmnopqrstuvwxyz{||||||||||}"
 };

int rvalues[LINES] = { 1, 18, 34, 33, 39 }, i;
int valid = 1, rc;

for(i=0; i<LINES && valid; i++) {
  rc = bit_to_ascii(core_data[i], phrase);
  if(rc != rvalues[i] || strcmp(phrase, correct[i])) {
 printf("Failed on test... %d\n\n", i+1);
 valid = 0;
  }
  else {
 printf("Passed test %d...\n\n", i+1);
  }
  printf("Your string ----------> '%s'\n", phrase);
  printf("Actual string --------> '%s'\n", correct[i]);
  printf("Your return value ----> %d\n", rc);
  printf("Actual return value --> %d\n", rvalues[i]);
  printf("Press the ENTER key to continue...");
  getchar( );
 }
 if(valid) {
  printf("\nCongratualtions!!! You passed all tests.\n");
  printf("You may hand in your assignment.\n");
 }
 else {
  printf("\nYou correctly sequenced %d/5 data blocks...\n", i-1);
  printf("Your program still needs some work!\n");
  printf("Keep at it!\n\n");
 }
 return 0;
 }

 int bit_to_ascii(const char core[ ], char data[ ]) {
   int i, rc = 0, j, inte[7], len, len2, m, rpt1, rptcounter, bin, lendata = 0, p = 0;
   char binarray[9], rpt[4], skp[9];
    rpt[4]='\0';
   for(i=0, j=0; core[i] != '\0'; i++) {
 switch(core[i]) {
 case '1':
 case '0':
  if(j<8) {
       binarray[j++] = core[i];
       binarray[j] = '\0';
    }
  else {
     binarray[j] = '\0';
     inte[0] = (binarray[0] - 48) * 128;
     inte[1] = (binarray[1] - 48) * 64;
     inte[2] = (binarray[2] - 48) * 32;
     inte[3] = (binarray[3] - 48) * 16;
     inte[4] = (binarray[4] - 48) * 8;
     inte[5] = (binarray[5] - 48) * 4;
     inte[6] = (binarray[6] - 48) * 2;
     inte[7] = (binarray[7] - 48) * 1;

     bin = inte[0] + inte[1] + inte[2] + inte[3] + inte[4] + inte[5] + inte[6] +inte[7];
     if(bin<=0 || bin >=32) {
     data[lendata] = bin;
     lendata++;
     }
     j = 0; /* resets j to 0 after 8 1's or 0's have been found */

     if(j<8) {
       binarray[j++] = core[i];
     }//end if
     }//end else
     case 'R':

    if(core[i+1] == 'P' && core[i+2] == 'T') {
      i=i+3;
      if(isdigit(core[i])) {
         rpt[0] = core[i];
         i++;

            if(isdigit(core[i])) {
               rpt[1] = core[i];
               i++;
                  if(isdigit(core[i])) {
                     rpt[2] = core[i];
                     i++;
                  }
            }

         rpt1 = atoi (rpt);
         //printf("\n\n%d\n\n", rpt1);
         len = strlen(binarray);
         for(rptcounter=0, j=0; rptcounter<rpt1; rptcounter++ ){ //loops rpt1 times
            if(len<8){
                      len2 = 8 - len;
                      m = len;
                      do {
                                  binarray[m]='0';
                                  m++;
                      }while (m != 8);
                      }
            inte[0] = (binarray[0] - 48) * 128;
            inte[1] = (binarray[1] - 48) * 64;
            inte[2] = (binarray[2] - 48) * 32;
            inte[3] = (binarray[3] - 48) * 16;
            inte[4] = (binarray[4] - 48) * 8;
            inte[5] = (binarray[5] - 48) * 4;
            inte[6] = (binarray[6] - 48) * 2;
            inte[7] = (binarray[7] - 48) * 1;
      bin = inte[0] + inte[1] + inte[2] + inte[3] + inte[4] + inte[5] + inte[6]+inte[7];
            data[lendata] = bin;
            lendata++;
         }
      }
      }
      break;
    case 'S':
   if(core[i+1] == 'K' && core[i+2] == 'P') {
   i=i+3;
   for(p=0;p!=8;i++) {
      switch(core[i]) {
      case '1':
      case '0':
           skp[p] = core[i];
           p++;
           break;
      }
   }
   }
    break;
  }//end case
  }//end for
   binarray[j] = '\0';
   len = strlen(binarray);
            if(len<8){
                      len2 = 8 - len;
                      m = len;
                      do {
                                  binarray[m]='0';
                                  m++;
                      }while (m != 8);
                      }
   inte[0] = (binarray[0] - 48) * 128;
   inte[1] = (binarray[1] - 48) * 64;
   inte[2] = (binarray[2] - 48) * 32;
   inte[3] = (binarray[3] - 48) * 16;
   inte[4] = (binarray[4] - 48) * 8;
   inte[5] = (binarray[5] - 48) * 4;
   inte[6] = (binarray[6] - 48) * 2;
   inte[7] = (binarray[7] - 48) * 1;
   bin = inte[0] + inte[1] + inte[2] + inte[3] + inte[4] + inte[5] + inte[6] + inte[7];
   data[lendata] = bin;
   lendata++;
   data[lendata]='\0';
   rc = strlen(data) + 1;
   if (rc==0) {
          rc++;
          }
   return rc;
}

最佳答案

另一个跳出来的问题是

char binarray[9], rpt[4], skp[9];
rpt[4]='\0';

尽管有效索引为 0-3，但您将 rpt[4] 设置为 0。

您正在写入 inte 的八个元素，

inte[0] = (binarray[0] - 48) * 128;
inte[1] = (binarray[1] - 48) * 64;
inte[2] = (binarray[2] - 48) * 32;
inte[3] = (binarray[3] - 48) * 16;
inte[4] = (binarray[4] - 48) * 8;
inte[5] = (binarray[5] - 48) * 4;
inte[6] = (binarray[6] - 48) * 2;
inte[7] = (binarray[7] - 48) * 1;

尽管它被声明为int i, rc = 0, j, inte[7], ...。

关于c - 与 C 赋值堆叠，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/10789561/

文章推荐： c - Posix正则表达式捕获组匹配序列

文章推荐： c - 我如何知道 sig_atomic_t 的值是否已更改？

文章推荐： c - 子进程恢复时不发出 SIGCHLD 信号

ios - UICollectionView 堆叠
如何将单元格(在 UICollectionView 中)堆叠在一起？ Feedly 做得很好，我想知道是否可以以某种方式操纵 zIndex 属性以在 UICollectionView 的导航中获得类似
css 堆叠 div
我正在尝试堆叠 div 以使用和图像显示顶部和底部淡入淡出。外部 div(“旋转器”)有一个背景图像，该图像在顶部和底部具有渐变，在中间是透明的。在中间，我想显示内容或图像，并将外部 div 背景图
CSS 堆叠 Div
我有两个动画(在 CSS 中)div，它们围绕彼此旋转。我想在中间为文本添加另一个 div。但是，如果我将 div 放在这两个中的任何一个中，它就会与父 div 一起设置动画。如果我尝试定位它，它就位
Android 堆叠 View
图中显示了我想要的 View 。最佳答案为此你可以采取 FrameLayout . 例如 - 1: 更新: 例如 - 2:精湛的示例和技巧，可在此处找到:http://w
tensorflow - 堆叠 LSTM 的初始状态结构
使用 tf.keras.layers.RNN 的 TensorFlow (1.13.1) 中多层/堆叠 RNN 的初始状态所需的结构是什么？ API？我尝试了以下方法: lstm_cell_size
r - ggplot2 - 堆叠/躲避条形图
我在制作条形图时遇到问题，其中 y 轴不是计数，而是变量的值。我使用stat=identity，这对于一个变量来说很好。但是，如果我有两个变量并且想要创建堆叠/闪避条形图怎么办？我这里有一些模拟数
r - 对路径列表中的栅格进行分组/堆叠，并提取每组的最小值
我有一个栅格路径列表(rplist = 912 raster pathe for 912 rasters (19yeras)(12months)(4weeks))如下: [1] "C:/Users
php - 堆叠 PHP 代码？
我已经完成了一个项目，现在需要更改该项目，以便在变量位于数组中时显示一个 div，如果变量不在数组中则显示另一个 div。通常我会这么做祝你愉快，但是我得到的代码已经包含大量 html 和 ph
r - ggplot2 - 堆叠/躲避条形图
我在制作条形图时遇到问题，其中 y 轴不是计数，而是来自变量的值。我使用 stat=identity，这对一个变量来说没问题。但是，如果我有两个变量并想创建一个堆叠/闪避条形图怎么办？我这里有一些
r - 对路径列表中的栅格进行分组/堆叠，并提取每组的最小值
我有一个栅格路径列表(rplist = 912 raster pathe for 912 rasters (19yeras)(12months)(4weeks))如下: [1] "C:/Users
java - 标签重叠(堆叠)有问题
我正在尝试将分数和耗时标签(scoreAndTimer)添加到我已经工作的贪吃蛇游戏代码中。问题是当我使用 ScoreAndTimer.setText(); 时它与之前的文本堆叠在一起。我尝试 se
gtk - 堆叠 GTK+ 小部件
有没有办法将 GTK+ 小部件放入堆栈中？ IE。在标签上放置一个按钮，使按钮覆盖标签的一部分。最佳答案您可以使用 GtkFixed 作为布局。这将允许您控制子小部件的确切位置，并且它们可以重叠。
java - 堆叠 ASM 访问者的正确方法是什么？
我有以下代码: for (Map.Entry e : classes.entrySet()) { ClassReader reader = e.getValue(); ClassWri
r - 根据ggplot2中类别的比例调整(堆叠)条宽
我正在尝试根据类别的计数(或比例)更改我的(堆叠)条宽，作为示例，我使用了钻石数据集。我想根据每个类别(变量 cut )的频率看到不同的宽度。我首先创建了一个变量 cut_prop然后用下面的代码绘制
c# - DispatcherTimer 堆叠 - UWP
我目前正在 UWP 中开展一个项目，我有一个 CommandBar，我想将其从 Hidden 变为 Compact 如果鼠标移动。五秒钟后(如果鼠标不移动)CommandBar 应该再次返回到Hidd
ios - 动画期间 subview 堆叠
我是 Swift 新手，并尝试在学习过程中编写一本交互式书籍。我使用 CATransform3DMakeRotation 创建了封面效果。正如您所看到的，当我堆叠 View 时，问题就出现了。如果我
android - 使用相机快照防止多项 Activity 堆叠
我已经阅读了 finish(); 命令和 FLAG_ACTIVITY_CLEAR_TOP 命令，还查看了 Common Ware 关于终止应用程序的回答，但我不确定如何放置这进入我的应用程序。基本上
c++ - 堆叠 Cg 着色器
在我的引擎中，我从成对的顶点/像素着色器文件中加载 Cg 着色器。我希望能够堆叠着色器以组合它们(照明+ Material 等)。除了将着色器分解为单独的函数然后从中创建单个着色器脚本字符串之外，您是
java - 相同的 Activity 堆叠
我有一个 Activity 应该自行完成并关闭应用程序。现在，在某些情况下，根据用户导航到 Activity 的方式而变化， Activity 正在堆叠。当 Activity 堆积时，然后调用 fin
python - 堆叠 CSV 文件的最快方法
我有 10 个具有完全相同的列和数据类型的 csv 文件。什么是最快/最有效的堆叠方式？ CSV1: col1 | col2 | col3 1 | 'a' | 0.1 2 | 'b'

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - 与 C 赋值堆叠