Question

如何从通过指针数组访问的字符串中读取每个字符？在下面的代码中，我目前在我的symCodes函数中生成了一个名为makeCodes的字符串指针数组。我想一次读取8个字符的字符串，我想将每个字符串连接在一起，然后通过char循环遍历该字符串，但symCodes中的字符串每个最多可以包含255个字符，所以我觉得这可能太多了一切都要处理。相反，我以为我可以逐字逐句地读取每个字符。

我已尝试过scanf或只是循环并始终以seg故障结束。在headerEncode()结束时，它靠近底部。我为每个单独的字符串提供了足够的内存，我尝试遍历指针数组并打印出每个单独的字符，但最终会出现seg错误。

我们赞赏任何以不同方式阅读字符串数组的建议，逐字符，最多n个字符数量。

编辑1：在使用-Wall和-W标志时，我已将程序更新为不再输出警告。我不再遇到一个段错误（耶！）但是我仍然不确定如何解决我的问题，我怎样才能读出一串指向字符串的指针，逐字符，最多n个数量人物？

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "huffman.h"

#define FAIL 0
#define SUCCESS 1

/* global 1 day arrays that hold chars and their freqs from file */

unsigned long globalFreqs[256] = {0};
unsigned char globalUsedCh[256] = {0};
char globalCodes[256] = {0};
unsigned char globalUniqueSymbols;
unsigned long totalCount = 0;

typedef struct HuffmanTreeNode* HTNode;



struct HuffmanTreeNode* globalSortedLL;
/*
  struct has the input letter, the letters frequency, and the left and irght childs
*/
struct HuffmanTreeNode
{
  char symbol;
  unsigned long freq;
  char *code;
  struct HuffmanTreeNode *left, *right;
  struct HuffmanTreeNode* next;
};

/* does it make sense to have a struct for the entire huffman tree to see its size? */
struct HuffmanTree
{
  unsigned size;
};

/*generate new node with given symbol and freq */
struct HuffmanTreeNode* newNode(char symbol, int freq)
{
  struct HuffmanTreeNode* newNode = malloc(sizeof(struct HuffmanTreeNode));
  newNode->symbol = symbol;
  newNode->freq = freq;
  newNode->left = newNode->right = NULL;
  return newNode;
}

/*current work in progress, i believe this is the way to insert it for a BST
/* will change for HuffmanTreenode once working
/*
*/

struct HuffmanTreeNode* insert(struct HuffmanTreeNode* node, struct HuffmanTreeNode* htnNew)
{

  struct HuffmanTreeNode* currentNode = node;

  if(currentNode == NULL || compareTwoNodes(htnNew, currentNode))
  {
    htnNew->next = currentNode;
    return htnNew;
  }
  else
  {
    while(currentNode->next != NULL && compareTwoNodes(currentNode->next, htnNew))
    {
      currentNode = currentNode->next;
    }
    htnNew->next = currentNode->next;
    currentNode->next = htnNew;
    return node;
  }
}

int compareTwoNodes(struct HuffmanTreeNode* a, struct HuffmanTreeNode* b)
{
  if(b->freq < a->freq)
  {
    return 0;
  }
  if(a->freq == b->freq)
  {
    if(a->symbol > b->symbol)
      return 1;
    return 0;
  }
  if(b->freq > a->freq)
    return 1;
}

struct HuffmanTreeNode* popNode(struct HuffmanTreeNode** head)
{
  struct HuffmanTreeNode* node = *head;
  *head = (*head)->next;
  return node;
}

/*convert output to bytes from bits*/
/*use binary fileio to output */
/*put c for individual character byte*/
/*fwrite each individual byte for frequency of symbol(look at fileio slides) */

/*
  @function:
  @param:
  @return:
*/
int listLength(struct HuffmanTreeNode* node)
{
  struct HuffmanTreeNode* current = node;
  int length = 0;
  while(current != NULL)
  {
    length++;
    current = current->next;
  }
  return length;
}

/*
  @function:
  @param:
  @return:
*/
void printList(struct HuffmanTreeNode* node)
{
  struct HuffmanTreeNode* currentNode = node;

  while(currentNode != NULL)
  {
    if(currentNode->symbol <= ' ' || currentNode->symbol > '~')
      printf("=%d", currentNode->symbol);
    else
      printf("%c", currentNode->symbol);
    printf("%lu ", currentNode->freq);
    currentNode = currentNode->next;
  }
  printf("\n");
}

/*
  @function:
  @param:
  @return:
*/
void buildSortedList()
{
  int i;
  for(i = 0; i < 256; i++)
  {
    if(!globalFreqs[i] == 0)
    {
      globalSortedLL = insert(globalSortedLL, newNode(i, globalFreqs[i]));
    }
  }

  printf("Sorted freqs: ");
  printList(globalSortedLL);
  printf("listL: %d\n", listLength(globalSortedLL));
}
/*
  @function: isLeaf()
  will test to see if the current node is a leaf or not
  @param:
  @return
*/

int isLeaf(struct HuffmanTreeNode* node)
{
  if((node->left == NULL) && (node->right == NULL))
    return SUCCESS;
  else
    return FAIL;
}

/*where I plan to build the actual huffmantree */
/*
  @function:
  @param:
  @return:
*/
struct HuffmanTreeNode* buildHuffmanTree(struct HuffmanTreeNode* node)
{
  int top = 0;
  struct HuffmanTreeNode *left, *right, *topNode, *huffmanTree;
  struct HuffmanTreeNode* head = node;
  struct HuffmanTreeNode *newChildNode, *firstNode, *secondNode;

  while(head->next != NULL)
  {
    /*grab first two items from linkedL, and remove two items*/
    firstNode = popNode(&head);
    secondNode = popNode(&head);
    /*combine sums, use higher symbol, create new node*/
    newChildNode = newNode(secondNode->symbol, (firstNode->freq +   secondNode->freq));
    newChildNode->left = firstNode;
    newChildNode->right = secondNode;
    /*insert new node, decrement total symbols in use */
    head = insert(head, newChildNode);
  }

  return head;
}

void printTable(char *codesArray[])
{
  int i;
  printf("Symbol\tFreq\tCode\n");
  for(i = 0; i < 256; i++)
  {
    if(globalFreqs[i] != 0)
    {
      if(i <= ' ' || i > '~')
      {
        printf("=%d\t%lu\t%s\n", i, globalFreqs[i], codesArray[i]);
      }
      else
      {
        printf("%c\t%lu\t%s\n", i, globalFreqs[i], codesArray[i]);
      }
    }
  }
  printf("Total chars = %lu\n", totalCount);
}

void makeCodes(
   struct HuffmanTreeNode *node,        /* Pointer to some tree node */
   char *code,          /* The *current* code in progress */
   char *symCodes[256], /* The array to hold the codes for all the symbols */
   int depth)           /* How deep in the tree we are (code length) */
{
    char *copiedCode;
    int i = 0;

    if(isLeaf(node))
    {
        code[depth] = '\0';
        symCodes[node->symbol] = code;
        return;
    }

    copiedCode = malloc(255*sizeof(char));
    memcpy(copiedCode, code, 255*sizeof(char));

    code[depth] = '0';
    copiedCode[depth] = '1';
    makeCodes(node->left, code, symCodes, depth+1);
    makeCodes(node->right, copiedCode, symCodes, depth+1);
}

/*
  @function: getFileFreq()
  gets the frequencies of each character in the given
  file from the command line, this function will also
  create two global 1d arrays, one for the currently
  used characters in the file, and then one with those
  characters frequencies, the two arrays will line up
  parallel
  @param: FILE* in, FILE* out,
  the current file being processed
  @return: void
*/
void getFileFreq(FILE* in, FILE* out)
{  
    unsigned long freqs[256] = {0};
    int i, t, fileCh;

    while((fileCh = fgetc(in)) != EOF)
    {
        freqs[fileCh]++;
        totalCount++;
    }
    for(i = 0; i < 256; i++)
    {
        if(freqs[i] != 0)
        {
            globalUsedCh[i] = i;
            globalFreqs[i] = freqs[i];
            if(i <= ' ' || i > '~')
            {
                globalUniqueSymbols++;
            }
            else
            {
                globalUniqueSymbols++;
            }
        }
    }
    /* below code until total count is for debugging purposes */
    printf("Used Ch: ");
    for(t = 0; t < 256; t++)
    { 
    if(globalUsedCh[t] != 0)
            {  
         if(t <= ' ' || t > '~')
        {
            printf("%d ", globalUsedCh[t]);
        }
        else
            printf("%c ", globalUsedCh[t]);
        }
    }
    printf("\n");
    printf("Freq Ch: ");
    for(t = 0; t < 256; t++)
    {
        if(globalFreqs[t] != 0)
        {  
            printf("%lu ", globalFreqs[t]);
        }
    }
    printf("\n");
    /* end of code for debugging/vizualazation of arrays*/
    printf("Total Count %lu\n", totalCount);
    printf("globalArrayLength: %d\n", globalUniqueSymbols);
}


void headerEncode(FILE* in, FILE* out, char *symCodes[256])
{
    char c;
    int i, ch, t, q, b, z;
    char *a;
    char *fileIn;
    unsigned char *uniqueSymbols;
    unsigned char *byteStream;
    unsigned char *tooManySym = 0;
    unsigned long totalEncodedSym;


    *uniqueSymbols = globalUniqueSymbols;


    totalEncodedSym = ftell(in);
    rewind(in);

    fileIn = malloc((totalEncodedSym+1)*sizeof(char));
    fread(fileIn, totalEncodedSym, 1, in);
    if(globalUniqueSymbols == 256)
    {
        fwrite(tooManySym, 1, sizeof(char), out);
    }
    else
    {
        fwrite(uniqueSymbols, 1, sizeof(uniqueSymbols)-7, out);
    }
    for(i = 0; i < 256; i++)
    {
        if(globalFreqs[i] != 0)
        {
            fwrite(globalUsedCh+i, 1, sizeof(char), out);
            fwrite(globalFreqs+i, 8, sizeof(char), out);
        }
    }
    for(t = 0; t < totalEncodedSym; t++)
    {
            fwrite(symCodes[fileIn[t]], 8, sizeof(char), out);
    }
    for(q = 0; q < totalEncodedSym; q++)
    {
        symCodes[q] = malloc(255*sizeof(char));
        a = symCodes[q];
        while(*a != '\0')
            printf("%c\n", *(a++));
    }

    printf("Total encoded symbols: %lu\n", totalEncodedSym);
    printf("%s\n", fileIn);
}

void encodeFile(FILE* in, FILE* out)
{
    int top = 0;
    int i;
    char *code;
    char *symCodes[256] = {0};
    int depth = 0;

    code = malloc(255*sizeof(char));

    getFileFreq(in, out);
    buildSortedList();
    makeCodes(buildHuffmanTree(globalSortedLL), code, symCodes, depth);
    printTable(symCodes);
    headerEncode(in, out, symCodes);



    free(code);
}

/*
void decodeFile(FILE* in, FILE* out)
{

}*/

Answer 1

您的代码中存在许多问题：

[major] 函数compareTwoNodes并不总是返回值。如果指示输出更多警告，编译器可以检测到此类问题。
[major] symbol中的成员HuffmanTreeNode应该有int类型。类型char作为索引值存在问题，因为它可以根据编译器配置和平台特性进行签名或取消签名。您认为char的值为0到255，这对char实际上具有-128范围的大多数平台都不正确。{{1 }}。使用127或unsigned char，但将int值转换为char以确保正确宣传。
[major] 比较unsigned char始终为false，因为if (globalUniqueSymbols == 256)是globalUniqueSymbols。对于8位字节，可能的字节值的最大数量确实为unsigned char，但它不适合256，使unsigned char成为globalUniqueSymbols。

int

[major] *uniqueSymbols = globalUniqueSymbols;将headerEncode存储到未初始化的指针中，绝对是未定义的行为，可能是分段错误。
[major] globalUniqueSymbols是指针的大小，而不是数组大小而不是类型的大小。而不是将其作为sizeof(uniqueSymbols)，sizeof(uniqueSymbols)-7
[major] fputc(globalUniqueSymbols, out);也不正确，因为fwrite(tooManySym, 1, sizeof(char), out);已初始化为tooManySym，即：它是0指针。您需要一个特殊值来告知源流中使用了所有字节值，请使用NULL并使用0进行编写。
您在函数fputc(0, out);之前嵌套了C样式注释，这不是一个错误，但容易出错且被认为是错误的样式。
函数insert应为newNode提供unsigned long类型的一致性。
函数freq包含未使用的局部变量：buildHuffmanTree，right和top。
变量topNode在函数i中未使用。
makeCodes中的许多未使用的变量：headerEncode，byteStream，c，ch ...
b是totalEncodedSym，在unsigned long停留的循环中使用正确类型的索引。
未使用的变量取消totalEncodedSym：encodeFile，i ...

编译器可以使用适当的警告级别检测其中大部分内容：top或gcc -Wall -W ...

程序逻辑中可能还有错误，但在解决上述主要问题之前，您无法看到这些错误。

从指针数组中读取字符串

1 个答案: