c - 函数中的双指针

Question

我正在尝试在二叉搜索树中插入字符串。

所以我要尝试的是，

从文件(包含指令集)中解析字符串，然后插入到函数中

insertOpcodeFromFile()。

所以这个函数将会执行

(*node) = Node_insert(&node,指令)。

该节点将是二叉树的根，位于 main 函数中。

所以用简单的方式解释一下，我想通过在包含插入函数的其他函数中使用双指针来操作(插入)主函数中的根指针。

我对指针有一个简单的理解，但在这种情况下，我认为我需要使用不止双指针。

请用这个例子清楚地解释一下双指针。

这是我的代码(我注释掉了 insert_node)

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

#ifndef BINARYTREE_H_
#define BINARYTREE_H_

typedef struct node *NodePtr;

typedef struct node {
  char   *word;
  int     count;
  NodePtr left;
  NodePtr right;
    } Node;

NodePtr Node_alloc();
NodePtr Node_insert(NodePtr node_ptr, char *word);
void clearArray(char a[]);
void insertOpcodeFromFile(FILE *opcodeFile, NodePtr *node);

void    Node_display(NodePtr);
char   *char_copy(char *word);

#endif



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

FILE * opFile;
FILE * progFile;
struct node *root = NULL;


if ( argc != 4) {               // # of flag check
    fprintf(stderr, " # of arguments must be 4.\n" );
    exit(1);
}

opFile = fopen ( argv[1], "r");
if(opFile == NULL)
        {
            fprintf(stderr,"There is no name of the opcode file\n");
            exit(1);
        }
progFile = fopen ( argv[2], "r");
if(progFile == NULL)
    {
            fprintf(stderr,"There is no name of the program file \n");
            exit(1);
    }

insertOpcodeFromFile(opFile, &root);
//Node_display(root);

}/* main is over */

void insertOpcodeFromFile(FILE *opcodeFile, NodePtr *node)
{
int fsize = 0;
int lengthOfInst = 0;
int c;
int i;
char buffer[100];
fsize = getFileSize(opcodeFile);
enum flag {ins,opc,form}; 
int flag = ins;
char instruction[6];
unsigned int opcode = 0;
unsigned char format;
 while (c != EOF)
{
    c = fgetc(opcodeFile);
    buffer[i++] = c;

    if (c == 32){
        switch (flag) {

        case ins:
            flag = opc;

            memcpy(instruction,buffer,i);
            instruction[i] = '\0';
            clearArray(buffer);
            i = 0;
           // printf("인스트럭션 : %s\n",instruction );
             break;

        case opc:
            flag = form;
            opcode = atoi(buffer);
            clearArray(buffer);
            i = 0;
           // printf("옵코드 : %d\n",opcode );
            break;

        default: 
             break;
        }/* end of switch */
    }/* end of if(space) */
    if((c == 10) || (c == EOF))
    {
        if (flag == form)
        {
            format = buffer[0];
            clearArray(buffer);
            i = 0;
           // printf("포멧: %c\n", format);

        }
        flag = ins;
       //node = Node_insert(node,instruction);


    }
}
//Node_display(node);
}
int getFileSize(FILE *opcodeFile)
{   int fsize = 0;
fseek(opcodeFile,0, SEEK_SET);
fseek(opcodeFile,0, SEEK_END);
fsize = (int)ftell(opcodeFile);
fseek(opcodeFile,0, SEEK_SET);
return fsize;
}
int countUntilSpace(FILE *opcodeFile, int currentPosition)
{   char readword[1];
char *space = " ";
char *nextLine = "/n";
int i = 0;
//printf("현재: %d\n",currentPosition );
while(1)
{   
    fread(readword, sizeof(char),1,opcodeFile);
    i++;

    if(strcmp(readword,space) == 0 || strcmp(readword,nextLine) == 0)
    {   
        //printf("break\n");
        break;
    }
}

fseek(opcodeFile,currentPosition ,SEEK_SET);
//printf("끝난 현재 :%d\n",ftell(opcodeFile) );
//printf("%I : %d\n",i );
return i - 1;
}
void clearArray(char a[])
{
memset(&a[0], 0, 100);
}

NodePtr Node_alloc()
{
return (NodePtr) malloc(sizeof(NodePtr));
}

NodePtr Node_insert(NodePtr node_ptr, char *word)
{
int cond;

if (node_ptr == NULL) {
    node_ptr = Node_alloc();
    node_ptr->word  = char_copy(word);
    node_ptr->count = 1;
    node_ptr->left  = node_ptr->right = NULL;
} else if ((cond = strcmp(word, node_ptr->word)) == 0) {
    node_ptr->count++;
} else if (cond < 0) {
    node_ptr->left = Node_insert(node_ptr->left, word);
} else {
    node_ptr->right = Node_insert(node_ptr->right, word);
}
return node_ptr;
}

void Node_display(NodePtr node_ptr)
{
if (node_ptr != NULL) {
    Node_display(node_ptr->left);
    printf("%04d: %s\n", node_ptr->count, node_ptr->word);
    Node_display(node_ptr->right);
}
}

char *char_copy(char *word)
{
char *char_ptr;

char_ptr = (char *) malloc(strlen(word) + 1);
if (char_ptr != NULL) {
    char_ptr = strdup(word);
}
return  char_ptr;
}

Answer 1

在本例中，在 main() 中，

Node *root;

为什么需要在改变 root 的函数中使用“双”指针( Node ** )是因为 root 值为在这些函数中设置。

例如，假设您要分配一个 Node 并将其设置为 root。
如果您执行以下操作

void alloc_root(Node *root) {
   root = malloc(sizeof (Node));
   // root is a function parameter and has nothing to do 
   // with the 'main' root
}
...
   // then in main
   alloc_root( root );
   // here main's root is not set

使用指向指针的指针(称为“双指针”)

void alloc_root(Node **root) {
   *root = malloc(sizeof (Node)); // note the *
}
...
   // then in main
   allow_root( &root );
   // here main's root is set

困惑可能来自于 main 中的 Node *root，root 是指向 Node 的指针。如何在函数 f 中设置整数 int i;？您可以使用 f(&i) 调用函数 f(int *p) { *p = 31415; } 将 i 设置为值 31415。

将 root 视为包含 Node 地址的变量，并且要在必须传递 &root 的函数中设置其值>。 root 是一个 Node *，它生成另一个 *，如 func(Node **p)。