2

我在编译 tldlist.c 文件时遇到问题。

我如何解决这些问题：

  • 隐式声明
  • 冲突类型
  • 不兼容的整数到指针的转换
  • 静态声明遵循非静态声明

请忽略未使用的变量/参数警告。我还没有实现一些方法。

注意： tldlist.h 不能以任何方式修改。

编译器错误：

bash-3.2$ gcc -c -W -Wall tldlist.c
tldlist.c:86:21: warning: implicit declaration of function 'tldnode_create' is invalid in C99 [-Wimplicit-function-declaration]
    TLDNode *node = tldnode_create(tld_name);
                    ^
tldlist.c:86:14: warning: incompatible integer to pointer conversion initializing 'TLDNode *' (aka 'struct tldnode *') with an expression of
      type 'int' [-Wint-conversion]
    TLDNode *node = tldnode_create(tld_name);
             ^      ~~~~~~~~~~~~~~~~~~~~~~~~
tldlist.c:92:10: warning: implicit declaration of function 'tldlist_add_node' is invalid in C99 [-Wimplicit-function-declaration]
    if (!tldlist_add_node(tld, tld_name, tld->root))
         ^
tldlist.c:71:7: warning: unused variable 'comparison' [-Wunused-variable]
  int comparison;
      ^
tldlist.c:110:12: error: static declaration of 'tldlist_add_node' follows non-static declaration
static int tldlist_add_node(TLDList *tld, char *tld_name, TLDNode *node) {
           ^
tldlist.c:92:10: note: previous implicit declaration is here
    if (!tldlist_add_node(tld, tld_name, tld->root))
         ^
tldlist.c:121:14: warning: incompatible integer to pointer conversion initializing 'TLDNode *' (aka 'struct tldnode *') with an expression of
      type 'int' [-Wint-conversion]
    TLDNode *new = tldnode_create(tld_name);
             ^     ~~~~~~~~~~~~~~~~~~~~~~~~
tldlist.c:128:14: warning: incompatible integer to pointer conversion initializing 'TLDNode *' (aka 'struct tldnode *') with an expression of
      type 'int' [-Wint-conversion]
    TLDNode *new = tldnode_create(tld_name);
             ^     ~~~~~~~~~~~~~~~~~~~~~~~~
tldlist.c:151:43: warning: unused parameter 'tld' [-Wunused-parameter]
TLDIterator *tldlist_iter_create(TLDList *tld) {
                                          ^
tldlist.c:159:41: warning: unused parameter 'iter' [-Wunused-parameter]
TLDNode *tldlist_iter_next(TLDIterator *iter) {
                                        ^
tldlist.c:174:10: error: conflicting types for 'tldnode_create'
TLDNode *tldnode_create(char *element) {
         ^
tldlist.c:86:21: note: previous implicit declaration is here
    TLDNode *node = tldnode_create(tld_name);
                    ^
8 warnings and 2 errors generated.

tldlist.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "date.h"
#include "tldlist.h"

struct tldlist {
  struct tldnode *root;
  long count;
  long size;
  Date *begin;
  Date *end;
};

/*
 * TODO: check the definition of element. 
 */
struct tldnode {
  struct tldnode *parent;
  struct tldnode *left;
  struct tldnode *right;
  char *element;
  long count;
};

/*
 * TODO: look at lecture slides
 */
struct tlditerator {
  struct tldlist *tld;
};

/*
 * tldlist_create generates a list structure for storing counts against
 * top level domains (TLDs)
 *
 * creates a TLDList that is constrained to the `begin' and `end' Date's
 * returns a pointer to the list if successful, NULL if not
 */
TLDList *tldlist_create(Date *begin, Date *end) {
  TLDList *tldl = (TLDList *)malloc(sizeof(TLDList));

  if (tldl != NULL) {
    tldl->root = NULL;
    tldl->count = 0;
    tldl->begin = date_duplicate(begin);
    tldl->end = date_duplicate(end);
  }
  return tldl;
};

/*
 * tldlist_destroy destroys the list structure in `tld'
 *
 * all heap allocated storage associated with the list is returned to the heap
 */
void tldlist_destroy(TLDList *tld) {
  if (tld != NULL)
    free(tld);
};

/*
 * tldlist_add adds the TLD contained in `hostname' to the tldlist if
 * `d' falls in the begin and end dates associated with the list;
 * returns 1 if the entry was counted, 0 if not
 */
int tldlist_add(TLDList *tld, char *hostname, Date *d) {
  char *tld_capture;
  char *tld_name;
  int tld_length;
  int comparison;

  // check if 'd' in the date range
  if (date_compare(tld->begin, d) > 0 || date_compare(tld->end, d) < 0)
    return 0;

  // get TLD from hostname
  tld_capture = strrchr(hostname, '.') + 1;
  tld_length = strlen(tld_capture);
  tld_name = (char *)malloc(sizeof(char)*(tld_length+1));
  tld_name[tld_length] = '\0';
  strcpy(tld_name, tld_capture);

  if (tld->root == NULL) {
    /* insert at root */
    TLDNode *node = tldnode_create(tld_name);
    node->count++;
    tld->root = node;
    tld->size++;
  } else {
    /* add elsewhere  */
    if (!tldlist_add_node(tld, tld_name, tld->root))
      free(tld_name);
    else
      tld->size++;
  }

  return 0;
};

/*
 * insert the TLD to the tree
 * consider 5 different cases:
 * (1) TLD name < current and there is a left node
 * (2) TLD name > current and there is a right node
 * (3) TLD name < current and there is no left node
 * (4) TLD name > current and there is no right node
 * (5) TLD name is equal to current
 */
static int tldlist_add_node(TLDList *tld, char *tld_name, TLDNode *node) {
  int comparison = strcmp(tld_name, node->element);

  if ((comparison < 0) && (node->left != NULL))
    /* case 1 */
    return tldlist_add_node(tld, tld_name, node->left);
  else if ((comparison > 0) && (node->right != NULL))
    /* case 2 */
    return tldlist_add_node(tld, tld_name, node->right);
  else if ((comparison < 0) && (node->left == NULL)) {
    /* case 3 */
    TLDNode *new = tldnode_create(tld_name);
    new->parent = node;
    new->count++;
    node->left = new;
    return 1;
  } else if ((comparison > 0) && (node->right == NULL)) {
    /* case 4 */
    TLDNode *new = tldnode_create(tld_name);
    new->parent = node;
    new->count++;
    node->right = new;
    return 1;
  } else {
    /* case 5 */
    node->count++;
    return 0;
  }
}
/*
 * tldlist_count returns the number of successful tldlist_add() calls since
 * the creation of the TLDList
 */
long tldlist_count(TLDList *tld) {
  return tld->count;
};

/*
 * tldlist_iter_create creates an iterator over the TLDList; returns a pointer
 * to the iterator if successful, NULL if not
 */
TLDIterator *tldlist_iter_create(TLDList *tld) {
  return NULL;
};

/*
 * tldlist_iter_next returns the next element in the list; returns a pointer
 * to the TLDNode if successful, NULL if no more elements to return
 */
TLDNode *tldlist_iter_next(TLDIterator *iter) {
  return NULL;
};

/*
 * tldlist_iter_destroy destroys the iterator specified by `iter'
 */
void tldlist_iter_destroy(TLDIterator *iter) {
  free(iter);
};

/*
 * tldnode_create() creates a new node that contains a TLD name
 * returns a pointer to the node if successful, NULL if not
 */
TLDNode *tldnode_create(char *element) {
  TLDNode *node = (TLDNode *)malloc(sizeof(TLDNode));

  if (node != NULL) {
    node->parent = NULL;
    node->left = NULL;
    node->right = NULL;
    node->count = 0;
  }
  return node;
}

/*
 * tldnode_tldname returns the tld associated with the TLDNode
 */
char *tldnode_tldname(TLDNode *node) {
  return node->element;
};

/*
 * tldnode_count returns the number of times that a log entry for the
 * corresponding tld was added to the list
 */
long tldnode_count(TLDNode *node) {
  return node->count;
};

tldlist.h：

#ifndef _TLDLIST_H_INCLUDED_
#define _TLDLIST_H_INCLUDED_

#include "date.h"

typedef struct tldlist TLDList;
typedef struct tldnode TLDNode;
typedef struct tlditerator TLDIterator;

/*
 * tldlist_create generates a list structure for storing counts against
 * top level domains (TLDs)
 *
 * creates a TLDList that is constrained to the `begin' and `end' Date's
 * returns a pointer to the list if successful, NULL if not
 */
TLDList *tldlist_create(Date *begin, Date *end);

/*
 * tldlist_destroy destroys the list structure in `tld'
 *
 * all heap allocated storage associated with the list is returned to the heap
 */
void tldlist_destroy(TLDList *tld);

/*
 * tldlist_add adds the TLD contained in `hostname' to the tldlist if
 * `d' falls in the begin and end dates associated with the list;
 * returns 1 if the entry was counted, 0 if not
 */
int tldlist_add(TLDList *tld, char *hostname, Date *d);

/*
 * tldlist_count returns the number of successful tldlist_add() calls since
 * the creation of the TLDList
 */
long tldlist_count(TLDList *tld);

/*
 * tldlist_iter_create creates an iterator over the TLDList; returns a pointer
 * to the iterator if successful, NULL if not
 */
TLDIterator *tldlist_iter_create(TLDList *tld);

/*
 * tldlist_iter_next returns the next element in the list; returns a pointer
 * to the TLDNode if successful, NULL if no more elements to return
 */
TLDNode *tldlist_iter_next(TLDIterator *iter);

/*
 * tldlist_iter_destroy destroys the iterator specified by `iter'
 */
void tldlist_iter_destroy(TLDIterator *iter);

/*
 * tldnode_tldname returns the tld associated with the TLDNode
 */
char *tldnode_tldname(TLDNode *node);

/*
 * tldnode_count returns the number of times that a log entry for the
 * corresponding tld was added to the list
 */
long tldnode_count(TLDNode *node);

#endif /* _TLDLIST_H_INCLUDED_ */
4

3 回答 3

5

这些错误是由缺少原型引起的 - 您在 tldlist.c 中调用的函数，编译器尚未看到其定义。

默认情况下，编译器假定任何未知函数都返回 int（旧版回归到非常早期的 C，如果返回类型是 int，您可以将其保留在外）。这就是您收到不兼容类型消息的原因:)

您需要向编译器提供函数的声明。您可以通过在 tldlist.c 顶部添加原型存根或通过创建定义它们的 tldnode.h 来做到这一点（因为它似乎主要是您缺少的与节点相关的函数）。

tldnode_create 的实现是

TLDNode *tldnode_create(char *element) {

所以你需要声明

TLDNode *tldnode_create(char *element);

在您尝试使用它之前：在 tldnode.h 或 tldlist.c 顶部的某处，例如在 tldnode 结构的声明之后。

/*
 * TODO: check the definition of element. 
 */
struct tldnode {
  struct tldnode *parent;
  struct tldnode *left;
  struct tldnode *right;
  char *element;
  long count;
};

TLDNode *tldnode_create(char *element);
于 2013-10-28T19:09:25.397 回答
1

从顶部开始：您的第一个警告是函数“tldnode_create”的隐式声明。您应该在 .h 文件中定义此函数原型。鉴于您无法修改它，您应该将原型放在 .c 文件的顶部

这会产生级联错误，因为编译器试图通过定义一个默认原型来提供帮助，该原型返回一个整数（因此您的下一个警告）关于不兼容的整数到指针的转换。

另外，为什么要声明函数静态？

于 2013-10-28T19:05:41.853 回答
1

您正在调用未在头文件或 c 文件中定义的函数（在调用它们之前）。查看。tldnode_create 未在任何地方声明。add 函数也不是。

我所看到的所有错误的问题也是如此。

在使用函数之前声明它们。

于 2013-10-28T19:05:42.400 回答