我是C的新手，我在编写C程序时遇到问题，该程序通过命令行参数获取可变数量的文件，并按字母顺序对单词进行排序，并仅输出唯一的单词，但包括频率。我设法按字母顺序通过用户输入对单词进行排序，但我不知道如何正确编写代码来进行文件输入，而且我也不知道如何只使用一次打印每个唯一单词它的频率。
这是我到目前为止得到的内容，它采用标准输入而不是文件并且缺少频率计数：
HTML <area> Tag, An image-map, with clickable areas:
答案 0 :(得分：2)
为了将文件中的单词读入仅包含唯一单词的数组，同时跟踪每次看到单词的出现次数，可以通过几种方式完成。一种简单直接的方法是保留2个独立的阵列。第一个是足够大小的2D字符数组，用于保存预期的单词数，第二个是包含每个单词看到次数的数字数组（unsigned int或size_t） >在相同的索引，因为该单词存储在字符数组中。
从文件中读取单词时唯一的挑战是确定一个单词是否已经看到之前，如果没有，新单词将被添加到给定的seen字符数组中然后在该索引处更新index和频率数组freq，以反映单词已被1时间（例如freq[index]++;）。
如果在检查seen中的单词列表时，您发现当前单词已经显示在索引X，则您跳过将该单词添加到seen，只需更新freq[X]++;
下面是一个简短的例子。试一试，如果您有任何问题请告诉我：
#include <stdio.h>
#include <string.h>
#define MAXW 100
#define MAXC 32
int main (int argc, char **argv) {
/* initialize variables & open file or stdin for reading */
char seen[MAXW][MAXC] = {{ 0 }};
char word[MAXC] = {0};
size_t freq[MAXW] = {0};
size_t i, idx = 0;
FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;
if (!fp) {
fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
return 1;
}
/* seen 1st word into 'seen' array, update index 'idx' */
if (fscanf (fp, " %32[^ ,.\t\n]%*c", word) == 1) {
strcpy (seen[idx], word);
freq[idx]++;
idx++;
}
else {
fprintf (stderr, "error: file read error.\n");
return 1;
}
/* read each word in file */
while (fscanf (fp, " %32[^ ,.\t\n]%*c", word) == 1) {
/* check against all words in seen */
for (i = 0; i < idx; i++) {
/* if word already in 'seen', update 'freq' count */
if (strcmp (seen[i], word) == 0) {
freq[i]++;
goto skipdup; /* skip adding word to 'seen' */
}
} /* add word to 'seen', update freq & 'idx' */
strcpy (seen[idx], word);
freq[idx]++;
idx++;
skipdup:
if (idx == MAXW) { /* check 'idx' against MAXW */
fprintf (stderr, "warning: MAXW words exceeded.\n");
break;
}
}
if (fp != stdin) fclose (fp);
printf ("\nthe occurrence of words are:\n\n");
for (i = 0; i < idx; i++)
printf (" %-28s : %zu\n", seen[i], freq[i]);
return 0;
}
<强>编译
gcc -Wall -Wextra -O3 -o bin/file_words_occur file_words_occur.c
<强>输入
$ cat dat/words.txt
the quick brown fox jumps over the lazy dog. the fox jumps over the dog to avoid the squirrel.
<强>输出
$ ./bin/file_words_occur <dat/words.txt
the occurrence of words are:
the : 8
quick : 1
brown : 1
fox : 2
jumps : 2
over : 2
lazy : 1
dog : 2
to : 1
avoid : 1
squirrel : 2
was : 1
in : 1
path : 1
of : 1
captain : 1
jack : 1
sparrow : 1
a : 1
pirate : 1
so : 1
brave : 1
on : 1
seven : 1
seas : 1
注意：删节词典中最长的词是28字符长（ Antidisestablishmentarianism ）。对于总共29个字符，它需要空间来终止字符。 MAXC 32的选择应该包含所有正常单词。
处理多个文件+按字母顺序排序单词/出现
如评论中所述，只需使用能够从stdin读取的代码，就可以使用现有代码处理多个文件。您需要做的只是cat file1 file2 file3 | ./prog_name。更新代码以处理多个文件作为参数也不困难。 （您可以使用for (j = 1, j < argc, j++)包装现有正文并打开/关闭所提供的每个文件名。（还需要对fp声明进行一些其他轻微调整）
但那有什么好玩的？每当你想在程序中不止一次地做同样的事情时，＆＃34;我应该把它作为一个功能＆＃34; 灯泡应该眨眼。这是考虑在代码中处理重复过程的正确方法。 （可以说，因为我们只做了一件事，不止一次，因为我们可以简单地将它包装在for循环中，在这种情况下，我们可以在没有函数的情况下完成 - 但是在哪里学习吗？）
好的，所以我们知道我们要将文件读取/频率计数代码移动到一个函数，但排序要求呢？我们需要将数据处理从2个数组更改为 struct 数组。为什么要从2数组转到处理结构中的数据？
按字母顺序对单词进行排序时，必须保持seen数组与freq数组之间的关系，以便在排序后，您具有正确的出现次数和正确的单词。您无法独立对数组进行排序并保持该关系。但是，如果我们在结构中放置该单词的单词和出现，那么我们可以通过单词对结构数组进行排序并且正确的出现次数仍然与正确的单词相关联。例如以下内容可行：
typedef struct {
char seen[MAXC];
size_t freq;
} wfstruct;
（wfstruct只是 word-frequency struct 的半描述性名称，它可以是对你有意义的任何内容）
在你的程序中，你将声明为一个类似于：
的数组 wfstruct words[MAXW];
（您实际上希望将每个成员初始化为零 - 这在下面的实际代码中完成）
如何对数组进行排序？ qsort是你的朋友。只要您可以传递qsort（1）数组，（2）要排序的元素数量，（3）元素的大小，以及（4），qsort将对任何事物的集合进行排序一个比较函数，它将const void指针指向它将要比较的元素。这总是让新的C程序员适合，因为你必须弄清楚（a）如何将数组的任何的元素作为指针传递，以及（b）然后如何处理获取数据你需要退出函数中的指针进行比较。
qsort的比较函数声明是：
int compare (const void *a, const void *b);
要编写比较功能，您只需要问自己＆＃34;我需要比较什么才能按照我想要的方式对我的收藏品进行排序？＆＃34; 在此如果您知道要在seen数组的每个元素中按单词wfstruct对结构数组进行排序。您知道seen将是一个简单的字符串，因此您可以使用strcmp进行排序。
然后你需要问自己的最后一件事是＆＃34;我是如何从seen（和const void *a）中获取*b字符串所以我可以将其提供给strcmp？＆＃34; 在此您知道const void *a必须代表您要排序的基本元素，即struct wfstruct。所以你知道const void *a是指向wfstruct的指针。由于它将是一个指针，因此您必须使用->运算符来取消结构的seen成员。 （例如，seen成员的访问权限为mystruct->seen。
但是＆＃34;关于取消无效指针的规则是什么？＆＃34; （答案：＆＃34;你无法推断无效指针＆＃34; 34; ）你如何处理这个？很简单，您只需在struct wfstruct函数和 typecase compare到a中声明类型为(wfstruct *)的指针。例如：
wfstruct *ap = (wfstruct *)a;
现在你有一个 good-ole pointer to struct wfstruct（或简称为pointer to wfstruct，因为我们在其声明中包含typedef wfstruct。您对b执行相同的操作，现在您可以将ap->seen和bp->seen传递给strcmp并对结构数组进行排序：
int compare (const void *a, const void *b)
{
wfstruct *ap = (wfstruct *)a;
wfstruct *bp = (wfstruct *)b;
return (strcmp (ap->seen, bp->seen));
}
在你的程序中调用qsort只不过是：
/* sort words alphabetically */
qsort (words, idx, sizeof *words, compare);
有了基础知识，您现在可以将所需的代码移动到一个函数中，以允许您将多个文件作为参数读取，保留文件之间看到的单词总数（以及它们的频率）和然后按字母顺序对结果数组进行排序。
注意：要跟踪多个文件（调用您的函数）之间的单词总数，您可以返回为每个文件收集的单词数作为读取函数的返回值，并保持总和那样，或者您可以简单地将指向您的总数的指针传递给读取函数并直接在函数中更新。我们将采取以下第二种方法。
把这些碎片放在一起，你得到：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXW 100
#define MAXC 32
typedef struct {
char seen[MAXC];
size_t freq;
} wfstruct;
int get_word_freq (wfstruct *words, size_t *idx, FILE *fp);
int compare (const void *a, const void *b);
int main (int argc, char **argv) {
/* initialize variables & open file or stdin for seening */
wfstruct words[MAXW] = {{{ 0 }, 0}};
size_t i, idx = 0;
FILE *fp = NULL;
if (argc < 2) { /* read from stdin */
get_word_freq (words, &idx, stdin);
}
else {
/* read each file given on command line */
for (i = 1; i < (size_t)argc; i++)
{ /* open file for reading */
if (!(fp = fopen (argv[i], "r"))) {
fprintf (stderr, "error: file open failed '%s'.\n",
argv[i]);
continue;
}
/* check 'idx' against MAXW */
if (idx == MAXW) break;
get_word_freq (words, &idx, fp);
}
}
/* sort words alphabetically */
qsort (words, idx, sizeof *words, compare);
printf ("\nthe occurrence of words are:\n\n");
for (i = 0; i < idx; i++)
printf (" %-28s : %zu\n", words[i].seen, words[i].freq);
return 0;
}
int get_word_freq (wfstruct *words, size_t *idx, FILE *fp)
{
char word[MAXC] = {0};
size_t i;
/* read 1st word into array, update index 'idx' */
if (*idx == 0) {
if (fscanf (fp, " %32[^ ,.\t\n]%*c", word) == 1) {
strcpy (words[*idx].seen, word);
words[*idx].freq++;
(*idx)++;
}
else {
fprintf (stderr, "error: file read error.\n");
return 1;
}
}
/* read each word in file */
while (fscanf (fp, " %32[^ ,.\t\n]%*c", word) == 1) {
/* check against all words in struct */
for (i = 0; i < *idx; i++) {
/* if word already 'seen', update 'words[i]. freq' count */
if (strcmp (words[i].seen, word) == 0) {
words[i].freq++;
goto skipdup; /* skip adding word to 'words[i].seen' */
}
} /* add to 'words[*idx].seen', update words[*idx].freq & '*idx' */
strcpy (words[*idx].seen, word);
words[*idx].freq++;
(*idx)++;
skipdup:
if (*idx == MAXW) { /* check 'idx' against MAXW */
fprintf (stderr, "warning: MAXW words exceeded.\n");
break;
}
}
fclose (fp);
return 0;
}
/* qsort compare funciton */
int compare (const void *a, const void *b)
{
wfstruct *ap = (wfstruct *)a;
wfstruct *bp = (wfstruct *)b;
return (strcmp (ap->seen, bp->seen));
}
<强>输出
$ ./bin/file_words_occur_multi dat/words.txt dat/words.txt
the occurrence of words are:
a : 2
avoid : 2
brave : 2
brown : 2
captain : 2
dog : 4
fox : 4
in : 2
jack : 2
jumps : 4
lazy : 2
of : 2
on : 2
over : 4
path : 2
pirate : 2
quick : 2
seas : 2
seven : 2
so : 2
sparrow : 2
squirrel : 4
the : 16
to : 2
was : 2
将索引（idx）作为非指针
如上所述，有两种方法可以跟踪多个文件中看到的唯一单词的数量：（1）传递索引并将总数保持在main，或者（2）传递指针索引并直接在函数中更新其值。上面的例子传递了一个指针。由于取消引用和正确使用指针值所需的附加语法对于C新手来说可能具有挑战性，因此这里是将idx作为简单变量传递并跟踪main中的总数的示例。
（注意：您需要以任何方式传递索引，无论您是将idx作为常规变量传递还是使用变量的副本，都可以选择它在函数中，或者是否将idx作为指针传递并直接在函数中对值进行操作）
以下是get_word_freq的简单更改以及main中所需的更改（注意：size_t被选为类型而不是int，因为数组索引可以永远不会否定）：
size_t get_word_freq (wfstruct *words, size_t idx, FILE *fp)
{
char word[MAXC] = {0};
size_t i;
/* read 1st word into array, update index 'idx' */
if (idx == 0) {
if (fscanf (fp, " %32[^ ,.\t\n]%*c", word) == 1) {
strcpy (words[idx].seen, word);
words[idx].freq++;
idx++;
}
else {
fprintf (stderr, "error: file read error.\n");
return idx;
}
}
/* read each word in file */
while (fscanf (fp, " %32[^ ,.\t\n]%*c", word) == 1) {
/* check against all words in struct */
for (i = 0; i < idx; i++) {
/* if word already 'seen', update 'words[i]. freq' count */
if (strcmp (words[i].seen, word) == 0) {
words[i].freq++;
goto skipdup; /* skip adding word to 'words[i].seen' */
}
} /* add to 'words[*idx].seen', update words[*idx].freq & '*idx' */
strcpy (words[idx].seen, word);
words[idx].freq++;
idx++;
skipdup:
if (idx == MAXW) { /* check 'idx' against MAXW */
fprintf (stderr, "warning: MAXW words exceeded.\n");
break;
}
}
fclose (fp);
return idx;
}
main所需的更改：
...
if (argc < 2) { /* read from stdin */
idx = get_word_freq (words, idx, stdin);
}
else {
/* read each file given on command line */
for (i = 1; i < (size_t)argc; i++)
{ /* open file for reading */
...
/* check 'idx' against MAXW */
if ((idx = get_word_freq (words, idx, fp)) == MAXW)
break;
}
}
...
如果您还有其他问题，请与我们联系。
答案 1 :(得分：1)
您的计划还有很多内容需要添加！
循环在命令行上给出的输入文件。一个简单的C方式可能是：
int main(int argc, char *argv[]) {
FILE *fd;
...
while (*(argv++) != NULL) {
if strcmp(*argv, "-") { /* allow - to stand for stdin */
fd = stdin;
}
else {
fd = fopen(*argv, "r");
if (fd == NULL) {
/* process error condition */
...
}
/* process file */
...
if (fd != stdin) fclose(fd); /* don't forget to close */
}
return 0;
}
按文字分割文件
char word[64];
int cr;
while ((cr = fscanf(fd, "%63s", word)) == 1) {
filter(word); /* optionally convert to lower case, remove punctuation... */
/* process word */
...
}
将单词存储在容器中并计算它们的出现次数。在最简单的级别，您可以使用具有线性搜索的数组，但树会更好。
unsigned int maxWord = 2048, totWord = 0, nWord = 0;
typedef {
char *word;
int count;
} stat;
stat * st = calloc(maxWord, sizeof(stat));
以后
void add(stat *st, const char * word) {
unsigned int i;
totWord += 1;
for (i=0; i<nWord; i++) {
if (strcmp(word, st[i].word) == 0) {
st[i].count += 1;
return;
}
}
if (nWord < maxWord) {
st[nWord].word = strdup(word);
st[nWord].count += 1;
nWord += 1;
}
}
您现在必须在上面粘合，对st数组（qsort）进行排序，每个单词的频率为((float) st[i].count) / totWord