関数内のダブルポインタ

Question

バイナリ検索ツリーに文字列を挿入しようとしています。

それでは、私がしようとしていますされ、ファイルから

解析文字列（命令セットが含まれている）、その後

insertOpcodeFromFileは（関数内で挿入します）。

ので、この関数は

（*ノード）= Node_insert（&ノード、命令）を実行します。

ノードは、main関数にあるバイナリツリーのルートになります。

簡単な説明では、私は挿入関数を含む他の関数でダブルポインタを使用して、メイン関数のルートポインタを操作（挿入）したいと思います。

私はポインタについて簡単に理解していますが、この状況では、私はダブルポインタ以上を使用する必要があります。

この例を使って明らかにダブルポインタについて説明してください。あなたが "ダブル" ポインタ（Node **）を使用する必要がないのはなぜここ

は私のコード（私は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を変更する関数は、これらの関数で設定する値が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 

をすれば混乱がrootはへのポインタであること、メインでNode *rootからおそらく来ますa Node。関数fに整数int i;をどのように設定しますか？ f(&i)を使用して、f(int *p) { *p = 31415; }関数を呼び出して、iを値31415に設定します。

rootは、アドレスがNodeになる変数であり、その値を&rootに渡す必要がある関数に設定することを検討してください。 rootはNode *であり、func(Node **p)のように別の*となります。