c中的字符串与字符数组的比较

Question

我试图编写一个编码和解码目的的代码。一旦我们有字典，形成的字典就存储在一个结构数组中。这种结构在下面

typedef struct Tuple { 
    char a; 
    char* cod; 
} result; 

原始字符串是字符数组

char str[100]; 

现在我们需要一个方法的字符的原始阵列与所形成的辞典中进行比较。 形成的词典是这样

a ---0 
b ---1 
c ---01 

实施例：原始的字符串是aabcab，那么编码应0010101

的字符串与字典数据如下比较的代码，但是当该码是执行它的结果如下：[Warning]传递'strcmp'的参数2使得整型指针没有一个强制转换[缺省情况下启用]。

帮助将不胜感激。

for(i=0; i<strlen(str);i++)//read the original string; 
    { 
     j=0; 
     while(j<number_of_elements_in_dictionary)// for above example=3 
     { 
      if (strcmp(str[i],values[j]->a)==0) //compare original string character with the //dictionary 
      { 
       printf("%s", values[j]->cod);//print corresponding code from //dictionary 
       j++; //check with the next value of the dictionary 
      } 
     }   
    } 
    printf("last=%s", str_en);//To print the dictionary data corresponding to //the original string data 

#include<string.h> 
 
#include<stdio.h> 
 
#include<limits.h> 
 
#include<stdlib.h> 
 
typedef struct node 
 
{ 
 
     char ch; 
 
     int freq; 
 
     struct node *left; 
 
     struct node *right; 
 
}node; 
 

 
typedef struct Tuple { 
 
    char a; 
 
    char* cod; 
 
}result; 
 
/*Declaring heap globally so that we do not need to pass it as an argument every time*/ 
 
/* Heap implemented here is Min Heap */ 
 
node * heap[1000000]; 
 
result * values[200]; 
 
int heapSize; 
 
\t char * str; 
 
\t char str_en[100]; 
 
// str_en[0] = '\0'; 
 
/*Initialize Heap*/ 
 
void Init() 
 
{ 
 
     heapSize = 0; 
 
     heap[0] = (node *)malloc(sizeof(node)); 
 
     heap[0]->freq = -INT_MAX; 
 
} 
 
/*Insert an element into the heap */ 
 
void Insert(node * element) 
 
{ 
 
     heapSize++; 
 
     heap[heapSize] = element; /*Insert in the last place*/ 
 
     /*Adjust its position*/ 
 
     int now = heapSize; 
 
     while(heap[now/2] -> freq >= element -> freq) 
 
     { 
 
       heap[now] = heap[now/2]; 
 
       now /= 2; 
 
     } 
 
     heap[now] = element; 
 
} 
 
node * DeleteMin() 
 
{ 
 
     /* heap[1] is #ifndef 
 

 
#elif 
 

 
#endifthe minimum element. So we remove heap[1]. Size of the heap is decreased. 
 
      Now heap[1] has to be filled. We put the last element in its place and see if it fits. 
 
      If it does not fit, take minimum element among both its children and replaces parent with it. 
 
      Again See if the last element fits in that place.*/ 
 
     node * minElement,*lastElement; 
 
     int child,now; 
 
     minElement = heap[1]; 
 
     lastElement = heap[heapSize--]; 
 
     /* now refers to the index at which we are now */ 
 
     for(now = 1; now*2 <= heapSize ;now = child) 
 
     { 
 
       /* child is the index of the element which is minimum among both the children */ 
 
       /* Indexes of children are i*2 and i*2 + 1*/ 
 
       child = now*2; 
 
       /*child!=heapSize beacuse heap[heapSize+1] does not exist, which means it has only one 
 
        child */ 
 
       if(child != heapSize && heap[child+1]->freq < heap[child] -> freq) 
 
       { 
 
         child++; 
 
       } 
 
       /* To check if the last element fits ot not it suffices to check if the last element 
 
        is less than the minimum element among both the children*/ 
 
       if(lastElement -> freq > heap[child] -> freq) 
 
       { 
 
         heap[now] = heap[child]; 
 
       } 
 
       else /* It fits there */ 
 
       { 
 
         break; 
 
       } 
 
     } 
 
     heap[now] = lastElement; 
 
     return minElement; 
 
} 
 
void encode(result *value, int s) 
 
{ 
 
int pos,i,j; 
 
pos=1; 
 
\t values[pos]=value;//Im here 
 
\t values[pos]->a =value->a; 
 
\t values[pos]->cod=value->cod; 
 
\t     
 
       printf("RESULT= %c and %s", values[pos]->a, values[pos]->cod); 
 
     
 
       pos++; 
 
       
 
      /*the problem exists here while executing the following for-loop, the code doesn't execute due to this for loop*/ 
 
      
 
       for(i=0; i<strlen(str);i++){ 
 
       \t j=0; 
 
       \t while(j<4) 
 
\t \t \t \t { 
 
\t \t \t \t  \t if(str[i]==values[j]->a) 
 
\t \t \t \t  \t { 
 
\t \t \t \t  \t \t printf("%s", values[j]->cod); 
 
\t \t \t \t  \t \t j++; 
 
\t \t \t \t \t } 
 
\t \t \t \t } \t \t } 
 
\t \t \t \t  
 
\t \t \t \t printf("last=%s", str_en); 
 
\t \t \t \t 
 
    
 
    } 
 
void print(node *temp,char *code, int s)//, char *buf) 
 
{ 
 
\t 
 
\t int i,pos=1,j; 
 
     if(temp->left==NULL && temp->right==NULL) 
 
     { 
 
       printf("\n\nchar %c code %s\n",temp->ch,code); 
 
       result * value = (result *) malloc(sizeof(result)); 
 
       value->a=temp->ch; 
 
       value->cod= code; 
 
       encode(value,s); 
 
       
 
\t \t return; 
 
      
 
       
 
     } 
 
     int length = strlen(code); 
 
     char leftcode[512],rightcode[512]; 
 
     strcpy(leftcode,code); 
 
     strcpy(rightcode,code); 
 
     leftcode[length] = '0'; 
 
     leftcode[length+1] = '\0'; 
 
     rightcode[length] = '1'; 
 
     rightcode[length+1] = '\0'; 
 
     print(temp->right,rightcode,s); 
 
     print(temp->left,leftcode,s); 
 
     
 
    }  
 

 
/* Given the list of characters along with their frequencies, our goal is to predict the encoding of the 
 
    characters such that total length of message when encoded becomes minimum */ 
 
int main() 
 
{ 
 
\t char buf[250]; 
 

 
\t char character[26]; 
 
\t int i = 0,j=0,count[26]={0}; 
 
    char c = 97; 
 
     Init(); 
 
     int distinct_char=0 ; 
 
     
 
     char ch; 
 
     int freq;  
 
     int iter; 
 
    
 
     printf("enter the string"); 
 
     scanf("%s", str); 
 
     printf("string=%s",str); 
 
     for (i=0; i<strlen(str);i++) 
 
     { 
 
     \t 
 
     for(j=0;j<26;j++) 
 
      { 
 
      if (tolower(str[i]) == (c+j)) 
 
       { 
 
        count[j]++; 
 
       } 
 
     } 
 
    } 
 
    for(j=0;j<26;j++) 
 
     { 
 
\t \t \t if(count[j]>0) 
 
\t \t \t { 
 

 
      printf("\n%c -> %d",97+j,count[j]); 
 
      distinct_char++; 
 
      character[j] = 97+j;  
 
\t \t \t } 
 

 
    \t } 
 
    \t printf("\n number of distinct_characters=%d\n", distinct_char); 
 
\t 
 
\t 
 
\t  if(distinct_char==1) 
 
     { 
 
       printf("char %c code 0\n",c); 
 
       return 0; 
 
     } 
 
     
 
     for(j=0;j<distinct_char;j++) 
 
     { 
 
     \t printf("\ncharacter= %c and the frequency=%d", character[j],count[j]); 
 
     \t node * temp = (node *) malloc(sizeof(node)); 
 
       temp -> ch = character[j]; 
 
       temp -> freq = count[j]; 
 
       temp -> left = temp -> right = NULL; 
 
       Insert(temp); 
 
      
 
     } 
 
     for(i=0;i<distinct_char-1 ;i++) 
 
     { 
 
       node * left = DeleteMin(); 
 
       node * right = DeleteMin(); 
 
       node * temp = (node *) malloc(sizeof(node)); 
 
       temp -> ch = 0; 
 
       temp -> left = left; 
 
       temp -> right = right; 
 
       temp -> freq = left->freq + right -> freq; 
 
       Insert(temp); 
 
     } 
 
     node *tree = DeleteMin(); 
 
     
 
     
 
     char code[512]; 
 
     code[0] = '\0'; 
 
    
 
    print(tree,code, distinct_char); 
 
    
 

 
}

Answer 1

作为警告提示，你在这里失踪的指针。 strcmp的签名读取

int strcmp(const char *s1, const char *s2); 

但两者参数实际上char型的（阵列索引使得char从char*，就像常规解除引用不和所述第二参数是char反正）。

但是，您真正需要的是将字符串中的单个字符与另一个字符进行比较。你可以只使用常规关系运算符：

if(str[i] == values[j]->a) 
{ 
    // ... 
} 

请注意，这只是回答您的精确的问题，但你的代码可能是错误的或无效的反正。

Answer 2

也许不是完全的“on-topic”，但是如果你使用查找表方法，你的代码会大大改善。来自str的输入字符应该用作带字典数组的索引 - 那么您只需要一个遍历输入字符串的循环。为了应对这一事实char可以有256个值，在外面你只需要几个你可以：

• 只使用char值的一部分指标 - 实际的索引之前减去一定的价值，你希望（第一个可打印字符编码），并将结果与​​LUT中的最大索引进行比较，浪费一些内存并在LUT中包括全部256个索引，使用另一个LUT将字符从输入转换为LUT中的索引 - 这样您就可以映射您不支持一个通用输出元素的所有字符，
• ...

这样你就不会在你的代码中的任何对比 - 只是索引（;