Cambiare indirizzo indicato dal puntatore utilizzando la funzione

Se ho dichiarato un puntatore p come int *p; nel modulo principale, posso cambiare l’indirizzo di contenuti p assegnando p=&a; dove a è un’altra variabile di tipo integer già dichiarato.
Ora voglio cambiare l’indirizzo utilizzando una funzione come::

void change_adrs(int*q)
{
    int *newad;
    q=newad;
}

Se io chiamo questa funzione dal modulo principale

int main()
{
    int *p;
    int a=0;
    p=&a; //this changes the address contained by pointer p
    printf("\n The address is %u ",p);
    change_adrs(p);
    printf("\n the address is %u ",p); //but this doesn't change the address
    return 0;
}

l’indirizzo contenuto è invariato. Cosa c’è di sbagliato con l’utilizzo di una funzione per la stessa attività?

  • Si passa il puntatore del valore.Se è necessario modificare il puntatore all’interno della funzione passa di riferimento…un doppio puntatore.
InformationsquelleAutor pranphy | 2012-11-17

 

5 Replies
  1. 37

    In C, le funzioni di argomenti vengono passati per valore. Così una copia della tua tesi e il cambiamento è fatto per la copia, non il puntatore che si aspetta di vedere modificati. Sarà necessario modificare la funzione accetta un puntatore doppio argomento e modificare l’privo di riferimenti argomento se si vuole fare questo.
    Per esempio

     void foo(int** p) {
          *p = 0;  /* set pointer to null */
     }
     void foo2(int* p) {
          p = 0;  /* makes copy of p and copy is set to null*/
     }
    
     int main() {
         int* k;
         foo2(k);   /* k unchanged */
         foo(&k);   /* NOW k == 0 */
     }

    Se hai il lusso di usare C++ un modo alternativo potrebbe essere quello di modificare la funzione accetta un riferimento a un puntatore.

    • Vorrei solo sottolineare che il C standard non garantisce l’assegnazione di p a 0 lo rende nullo.
  2. 12

    In C, le variabili sono passati per valore – una copia del puntatore viene passato alla funzione. Utilizzare un altro puntatore a puntatore, invece:

    void change(int **p, int *someOtherAddress)
    {
        *p = someOtherAddress;
    }
    
    int a = 1, b = 2;
    int *p = &a;
    
    printf("*p = %d\n", *p);
    change(&p, &b);
    printf("*p = %d\n", *p);

    Stampa

    *p = 1
    *p = 2
    • Questo è stato utilmente.
  3. 2

    Se si desidera modificare il contenuto di una variabile in una funzione in C, l’indicatore è un pò variabile, è necessario passare dalla puntatore o riferimento indiretto utilizzando sempre & indirizzo e * risolvere gli operatori. Voglio dire * operatore è sempre usato e preceduta quando si modifica il valore di una variabile.

    #include <stdio.h>
    #include <stdlib.h>
    
    
    void changeIntVal(int *x) {
        *x = 5;
    }
    
    void changePointerAddr(int **q) {
        int *newad;
        *q = newad;
    }
    
    void changePPAddr(int ***q) {
        int **dummy;
        *q = dummy;
    }
    
    int main() {
        int *p;
        int **pp;
        int *tempForPP;
        int a = 0;
        printf("\n The address pointing by p -> %p, pp -> %p, value of a -> %d ", p, pp, a);
    
    
        p = &a;
        pp = &tempForPP;
        printf("\n The address pointing by p -> %p, pp -> %p, value of a -> %d ", p, pp, a);
    
        changeIntVal(&a);        //----
                                 //   |---
        changePointerAddr(&p);   //----  |---->  parts of what I mean
                                 //   |---
        changePPAddr(&pp);       //----
    
        printf("\n The address pointing by p -> %p, pp -> %p, value of a -> %d ", p, pp, a);
    
        return 0;
    
    }
  4. 1

    Per un tipo di dati di base, come un int, i doppi puntatori non sono necessari. È possibile scrivere direttamente in un indirizzo dove il int è memorizzato, il suo indirizzo di un puntatore a funzione chiamata. Questo è a differenza di un char array (“stringa”), dove la dimensione di ciò che viene evidenziato è variabile e si deve quindi utilizzare un altro livello di riferimento indiretto quando si cambia dall’interno di una funzione chiamata. Prova questo:

    void foo(int *oldVal)
    {
        int newVal = 99;    //or whatever you want
        *oldVal = newVal;
    }
    
    int main(int argc, char *argv[])
    {
        int someVal = 0;
        foo(&someVal);      //we send its address to foo()
    
        printf("someVal is now %d.\n", someVal);
    
        return EXIT_SUCCESS;
    }
    • Questa non è la risposta alla domanda !, egli chiede di cambiare indirizzo del puntatore non valore del puntatore
  5. 0

    Questo non cambia il valore dip perché il q in funzione di locale e di cambiamento che la funzione non si riflette in main così passare l’indirizzo di p invece di passare p dal valore

    Utilizzare questa sintassi riportata di seguito

      void change_adrs(int **q)
      {
      int * otheraddess;
      *q = otheraddress; 
      }

    e chiamata come questo change_adrs(&p);

    O, si ha in un altro modo :
    modificare il tipo di ritorno della funzione e cattura l’indirizzo restituito.

    int* change_adrs(int *q)
          {
          int * otheraddess;
          q = otheraddress;
          return q; 
          }
    
    
    int main()
    {
     p=change_adrs(p);
     return 0;
    }

Lascia un commento