读取文件中可打印ASCII字符的字节数

我必须编写一个从命令行获取文件名的程序。 然后它从文件中读取几个字节，查找可打印字符的字符串（ASCII值介于

32

和

126

十进制之间）。 然后打印出字符串。 字符串是至少包含

4个

连续可打印字符的运行，并在遇到不可打印字符时结束。 只要找到这样的字符串，就在新行上打印出来

到目前为止，我得到的是：

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

int main(int argc, char *argv[]){
    FILE *fp;
    fp = fopen(argv[1], "rb");
    char buffer;

    while(fp != NULL)
    {
        fread(&buffer, 1, 1, fp);
    }

    fclose(fp);
}

#包括
#包括
int main（int argc，char*argv[]）{
文件*fp；
fp=fopen（argv[1]，“rb”）；
字符缓冲区；
while（fp！=NULL）
{
fread（缓冲区，1，1，fp）；
}
fclose（fp）；
}

我认为这样做的目的是从命令行获取程序，逐个读取文件的所有字节，并将它们存储到

缓冲区中。
现在我需要检查数组的每个部分，看看每个元素是否在
32
和
136
之间。
如果是，我将这些字节添加到另一个数组中，直到有一个字节不在此范围内。
对整个
缓冲区执行此操作。
这是一种代码方法，到目前为止是否正确？
稍微更改一下while循环。您要检查的是文件是否在循环中退出，该循环不会获取所需的结果

fp与NULL比较，以确定文件打开是否成功，因为fopen在打开文件时返回文件地址，或者NULL表示出现了问题

if( fp == NULL )
{
  perror("Error while opening the file\n");
  exit(0);
}

您需要执行以下操作：

while( ( ch = fgetc(fp) ) != EOF ) { // reads character by character from the file 
     if((ch <32) || (ch>136))   // check if it is in range to printed
        break;
     else
        printf("%c",ch);   // format whoever you want
} 

while（（ch=fgetc（fp））！=EOF）{//从文件中逐个字符读取
if（（ch 136））//检查是否在打印范围内
打破
其他的
printf（“%c”，ch）；//格式化任何您想要的格式
} 
如果我理解正确，您希望程序从文件中读取字符（文件可能包含不可打印字符），并检查字符是否在32到126（可打印字符）范围内。如果是，则将该字符添加到缓冲区并读取更多字符，直到找到不可打印的字符。它还应该确保字符串至少有4个字符；字符串应打印在换行符上。
以下是可能对您有所帮助的代码。它是用gcc编译的，我希望它也能为您工作

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


int main(int argc, char *argv[]) {

FILE *fp;
char buf[100], ch; //the size of the array would vary according to your need
int i=0;

//check for enough arguments
if(argc<2)
{
    printf("\nInsufficient Arguments.\n");
    printf("\nUsage: PrintChar <file>\n\n");
    return 1;
}

//open the file in binary mode and check for exisitence of the file
if((fp = fopen(argv[1], "rb"))== NULL) 
{
    printf("\nError: Unable to open the file.\n");
    return 2;
}

i=0;
while( (ch = fgetc(fp))!=EOF )
{   
    //check for the range
    if(ch>=32 && ch<=126)
    {
        buf[i] = ch; i++;

        //This loop will run till it find a next unprintable character (not between the range of 32 and 126
        //we also check for the EOF while reading the characters
        while( ( (ch = fgetc(fp))>=32 && ch<=126 ) && ch!=EOF )
        {
            buf[i] = ch; i++;
        }
        buf[i] = '\0'; //adding the NULL character

        //if the string is at least of 4 letters, print it
        if(i>=4)
         printf("\n%s", buf);

        //reset the counter
        i=0;

    }

}
fclose(fp);

return 0;

这是程序的输出：
C:\Users\shine\Documents\MYCPROGS\forStackoverflow>printchar test.txt

This is a string
anotherline of text #$%#$%#$% #$% #$%345#$$%&$&@#$!##~######@
345#$%@#$%@#452353453$%@#$%#$%$%%^&%^*4234346443754754451}
345345
-------------------------------------------------------------------

希望这会有帮助。我这样做很匆忙，所以如果您发现其中有错误，请告诉我。
每次读取一个字符，找到足够长的字符串时写入，或者必须：

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

int
main(int argc, char *argv[])
{
    size_t min_str_len = 4;
    size_t buf_len = 4; /* Must greater than or equal to min_str_len */
    char buf[buf_len], ch;
    size_t out_len, last_len;

    last_len = out_len = 0;
    while (fread(&ch, 1, 1, stdin) > 0) {
        if (isprint(ch)) {
            buf[out_len++] = ch;
            if (out_len >= buf_len) {
                fwrite(buf, 1, out_len, stdout);
                last_len += out_len;
                out_len = 0;
            }
        }
        else {
            if (out_len + last_len >= min_str_len) {
                fwrite(buf, 1, out_len, stdout);
#ifdef NEWLINE
                fwrite("\n", 1, 1, stdout);
#endif
                last_len = out_len = 0;
            }
            else {
                out_len = 0;
            }
        }
    }

    exit(EXIT_SUCCESS);
}

#包括
#包括
#包括
int
main（int argc，char*argv[]）
{
尺寸最小长度长度=4；
大小为4；/*必须大于或等于最小长度*/
char buf[buf_len]，ch；
最后一列的尺寸；
last_len=out_len=0；
而（fread（&ch，1，1，stdin）>0）{
如果（iPrint（ch））{
buf[out_len++]=ch；
if（out_len>=buf_len）{
写入（buf，1，out_len，stdout）；
last_len+=out_len；
out_len=0；
}
}
否则{
如果（超出长度+最后长度>=最小长度）{
写入（buf，1，out_len，stdout）；
#ifdef换行符
写入（“\n”，1，1，标准输出）；
#恩迪夫
last_len=out_len=0；
}
否则{
out_len=0；
}
}
}
退出（退出成功）；
}


如果您希望每次读取超过一个字节，则“至少4个连续可打印字符”将使其变得有点棘手：

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

int
main(int argc, char *argv[])
{
    size_t str_min_len = 4;
    size_t buf_len = 1024; /* Must greater than or equal to str_min_len */
    char in_buf[buf_len], out_buf[buf_len];
    size_t out_len, in_len, last_len;

    last_len = out_len = 0;
    while ((in_len = fread(in_buf, 1, buf_len, stdin)) > 0) {
        assert(out_len == 0);
        for (size_t i = 0; i < in_len; i++) {
            char ch = in_buf[i];
            if (isprint(ch)) {
                out_buf[out_len++] = ch;
            }
            else {
                if (out_len + last_len >= str_min_len) {
                    fwrite(out_buf, 1, out_len, stdout);
#ifdef NEWLINE 
                    /* Write a newline between strings. */
                    fwrite("\n", 1, 1, stdout);
#endif
                    last_len = 0;
                }
                out_len = 0;
            }
        }

        if (0 < out_len && out_len < str_min_len) {
            size_t pad_len = str_min_len - out_len;
            for (size_t i = 0; i < pad_len; i++) {
                char ch;
                if (fread(&ch, 1, 1, stdin) < 1) {
                    exit(EXIT_SUCCESS);
                }
                else if (isprint(ch)) {
                    out_buf[out_len++] = ch;
                }
                else {
                    break;
                }
            }
        }

        if (out_len >= str_min_len) {
            fwrite(out_buf, 1, out_len, stdout);
            last_len = out_len;
            out_len = 0;
        }
        else {
            last_len = out_len = 0;
        }
    }

    exit(EXIT_SUCCESS);
}

#包括
#包括
#包括
#包括
int
main（int argc，char*argv[]）
{
尺寸、长度、最小长度=4；
大小\u t buf\u len=1024；/*必须大于或等于str\u min\u len*/
char in_buf[buf_len]，out_buf[buf_len]；
尺寸外、内、末；
last_len=out_len=0；
而（（in_len=fread（in_buf，1，buf_len，stdin））>0）{
断言（out_len==0）；
对于（大小i=0；i=str\u min\u len）{
写入（输出buf，1，输出len，stdout）；
#ifdef换行符
/*在字符串之间写一个换行符*/
写入（“\n”，1，1，标准输出）；
#恩迪夫
最后的长度=0；
}
out_len=0；
}
}
if（0=str\u min\u len）{
写入（输出buf，1，输出len，stdout）；
last_len=out_len；
out_len=0；
}
否则{
last_len=out_len=0；
}
}
退出（退出成功）；
}
我查看了这个，它在大多数情况下都应该有效。但是，假设读入的字符串有7个连续字符。然后，下一个字符串的条纹仅为4。上一个的最后3个仍然在那里
buf
我想。如果你明白我的意思。哦，是的，谢谢你指出这一点。您可以添加另一行代码以使数组为空，类似于下面的buf[0]='\0'；i=0后；
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>

int
main(int argc, char *argv[])
{
    size_t str_min_len = 4;
    size_t buf_len = 1024; /* Must greater than or equal to str_min_len */
    char in_buf[buf_len], out_buf[buf_len];
    size_t out_len, in_len, last_len;

    last_len = out_len = 0;
    while ((in_len = fread(in_buf, 1, buf_len, stdin)) > 0) {
        assert(out_len == 0);
        for (size_t i = 0; i < in_len; i++) {
            char ch = in_buf[i];
            if (isprint(ch)) {
                out_buf[out_len++] = ch;
            }
            else {
                if (out_len + last_len >= str_min_len) {
                    fwrite(out_buf, 1, out_len, stdout);
#ifdef NEWLINE 
                    /* Write a newline between strings. */
                    fwrite("\n", 1, 1, stdout);
#endif
                    last_len = 0;
                }
                out_len = 0;
            }
        }

        if (0 < out_len && out_len < str_min_len) {
            size_t pad_len = str_min_len - out_len;
            for (size_t i = 0; i < pad_len; i++) {
                char ch;
                if (fread(&ch, 1, 1, stdin) < 1) {
                    exit(EXIT_SUCCESS);
                }
                else if (isprint(ch)) {
                    out_buf[out_len++] = ch;
                }
                else {
                    break;
                }
            }
        }

        if (out_len >= str_min_len) {
            fwrite(out_buf, 1, out_len, stdout);
            last_len = out_len;
            out_len = 0;
        }
        else {
            last_len = out_len = 0;
        }
    }

    exit(EXIT_SUCCESS);
}