So ändern Sie einen Zeiger durch einen Parameter

Question

So möchte ich einen Zeiger auf eine Funktion übergeben und diese Funktion haben, ändern Sie den Zeiger aus dieser Funktion. Wie mache ich das im Allgemeinen? Hier drin?

EDIT:

Seit der treeNode ist eine Struktur von Zeigern I nodePtr->vendorDataRef innerhalb der removeLeftMostNode(...) Funktion zu übernehmen wollen, und es irgendwie an die aufrufende Funktion zurück. Ich dachte, ich dies durch einen Parameter removeLeftMostNode(...) tun könnte daher removeLeftMostNode(...aVendor* vendorDataRef)

dh

aBst::treeNode * aBst::removeNode(aBst::treeNode * nodePtr) 
{ 
    aVendor * tempVendorPtr; //<----...to be assigned to this 
    treeNode * nodeToConnectPtr, * tempPtr; 
    ... 
    tempPtr = removeLeftMostNode(nodePtr->right, &tempVendorPtr); 
    ... 
} 

aBst::treeNode * aBst::removeLeftMostNode(aBst::treeNode * nodePtr, aVendor* vendorDataRef) 
{ 
    if(nodePtr->left == NULL) 
    { 
     //Target acquired, modify the value of vendorData through parameter 
     vendorDataRef = nodePtr->vendorData; //<---I want this pointer... 
     return removeNode(nodePtr); 
    } 
    else 
     return removeLeftMostNode(nodePtr->left, vendorData); 
    } 

Dies ist die treeNode struct

struct treeNode 
{ 
    aVendor * vendorData; 
    treeNode * left; 
    treeNode * right; 
}; 

Wie Sie sich vorstellen können, das ist ein Teil des Codes Entfernen Sie einen Eintrag aus einem binären Suchbaum. Dies ist der Code, der es indirekt aufruft.

bool aBst::remove(char nameOfVendor[]) 
{ 
    bool failControl = false; 

    removeValue(root, nameOfVendor, failControl); 

    return failControl; 
} 

aBst::treeNode * aBst::removeValue(aBst::treeNode * subTreePtr, char nameOfVendor[], bool& success) 
{ 
    //Note: the subTreePtr should be root in initial call 
    treeNode * tmpPtr; 
    char name[MAX_CHAR_LENGTH]; 

    subTreePtr->vendorData->getName(name); 

    if(subTreePtr == NULL) //Empty Tree 
    { 
     success = false; 
     return NULL; 
    } 
    else if(strcmp(name, nameOfVendor) == 0) //Evaluates to true if there is a match 
     { 
      //Item is in root of subTreePtr 
      subTreePtr = removeNode(subTreePtr); 
      success = true; 
      return subTreePtr; 
     } 
     else if(strcmp(name, nameOfVendor) < 0) // Go left 
      { 
       tmpPtr = removeValue(subTreePtr->left, nameOfVendor, success); 
       subTreePtr->left = tmpPtr; 
       return subTreePtr; 
      } 
      else // Go Right 
      { 
       tmpPtr = removeValue(subTreePtr->right, nameOfVendor, success); 
       subTreePtr->right = tmpPtr; 
       return subTreePtr; 
      } 
} 

Answer 1

Wie kann ich tun, dass im Allgemeinen?

Um ein beliebiges Objekt zu ändern, sei es ein Objekt oder ein Zeiger auf ein Objekt, können Sie einen Verweis darauf übergeben.

void foo(int& i) 
{ 
    // Assign to i. The change will be visible in the calling function. 
    i = 10; 
} 

void bar(int*& ptr) 
{ 
    // Assign to ptr dynamically allocated memory. 
    // The memory will be valid in the calling function. 
    ptr = new int[20]; 
} 

int main() 
{ 
    int i; 
    int* ptr; 

    foo(i); // When the function returns, i will be 10 
    bar(ptr); // When the function returns ptr will point to an array of 10 ints 
    ptr[5] = 20; // OK since memory for ptr was allocated in bar. 

    ... 

    // Deallocate memory to prevent memory leak. 
    delete [] ptr; 
}