C 使用函数更改指针包含的地址

如果我将指针

p

声明为

int*p

；在主模块中，我可以通过分配

p=&a来更改
p
中包含的地址

其中

a

是另一个已声明的整数变量。 现在，我想使用以下函数更改地址：

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

如果我从主模块调用此函数

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;
}

---

地址内容不变。为同一任务使用函数有什么问题？

在C中，函数参数是按值传递的。因此，将为参数创建一个副本，并对该副本进行更改，而不是希望看到修改的实际指针对象。如果要执行此操作，需要更改函数以接受指针指向指针的参数，并更改取消引用的参数。 比如说

 void foo(int** p) {
      *p = NULL;  /* set pointer to null */
 }
 void foo2(int* p) {
      p = NULL;  /* makes copy of p and copy is set to null*/
 }

 int main() {
     int* k;
     foo2(k);   /* k unchanged */
     foo(&k);   /* NOW k == NULL */
 }

---

如果您有使用C++的优势，另一种方法是更改函数以接受对指针的引用。因此，将为参数创建一个副本，并对该副本进行更改，而不是希望看到修改的实际指针对象。如果要执行此操作，需要更改函数以接受指针指向指针的参数，并更改取消引用的参数。 比如说

 void foo(int** p) {
      *p = NULL;  /* set pointer to null */
 }
 void foo2(int* p) {
      p = NULL;  /* makes copy of p and copy is set to null*/
 }

 int main() {
     int* k;
     foo2(k);   /* k unchanged */
     foo(&k);   /* NOW k == NULL */
 }

---

如果您有使用C++的优势，可选择的方法是更改函数以接受对指针的引用。

这不会改变<代码> p>代码>的实际值，因为函数中的<代码> q>代码>该函数是局部的，并且该函数的变化不会反映在<代码>主< /代码>中，因此传递“代码> P<代码>的地址>而不是按值传递

p

使用下面的语法

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

像这样调用

change\u adrs（&p）

或者，你有其他方法：
更改函数的返回类型并捕获返回的地址

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


int main()
{
 p=change_adrs(p);
 return 0;
}

这不会改变
p
的实际值，因为
q
in函数是该函数的本地函数，该函数的变化不会反映在
main
中，因此传递
p
的地址，而不是按值传递
p

使用下面的语法

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

像这样调用
change\u adrs（&p）

或者，你有其他方法：
更改函数的返回类型并捕获返回的地址

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


int main()
{
 p=change_adrs(p);
 return 0;
}

在C语言中，变量是通过值传递的——指针的副本被传递给函数。改为使用指向该指针的另一个指针：

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);

这张照片

*p = 1
*p = 2

在C语言中，变量是通过值传递的——指针的副本被传递给函数。改为使用指向该指针的另一个指针：

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);

这张照片

*p = 1
*p = 2

对于基本数据类型，例如
int
，不需要双指针。您可以直接写入存储
int
的地址，将其地址视为被调用函数中的指针。这与
char
数组（“字符串”）不同，在该数组中，所指向的内容的大小是可变的，因此，当从被调用函数中更改它时，必须使用另一个间接级别。试试这个：

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;
}

对于基本数据类型，例如
int
，不需要双指针。您可以直接写入存储
int
的地址，将其地址视为被调用函数中的指针。这与
char
数组（“字符串”）不同，在该数组中，所指向的内容的大小是可变的，因此，当从被调用函数中更改它时，必须使用另一个间接级别。试试这个：

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;
}

如果您想在C中的函数中更改变量的内容，指针也是一种变量，您必须通过指针或间接引用来传递它，方法是始终使用
&
地址和
*
解引用运算符。我的意思是，在更改变量值时，始终使用
*
运算符并在其前面

#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;

}

#包括
#包括
void changeIntVal（int*x）{
*x=5；
}
无效变更点地址（整数**q）{
int*newad；
*q=newad；
}
无效更改地址（int***q）{
int**假人；
*q=假人；
}
int main（）{
int*p；
国际**pp；
int*tempForPP；
int a=0；
printf（“\n由p->%p，pp->%p，a->%d的值所指向的地址”，p，pp，a）；
p=&a；
pp=&tempForPP；
printf（“\n由p->%p，pp->%p，a->%d的值所指向的地址”，p，pp，a）；
changeIntVal（&a）；//----
//    |---
changePointerAddress（&p）；//----我的意思的一部分
//    |---
changepaddr（&pp）；//----
printf（“\n由p->%p，pp->%p，a->%d的值所指向的地址”，p，pp，a）；
返回0；
}
如果你想在C中改变函数中变量的内容，指针也是一种变量，你必须通过指针或间接引用来传递它，总是使用
&
地址和
*
解引用操作符。我的意思是，在更改变量值时，始终使用
*
运算符并在其前面

#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;

}

#包括
#包括
void changeIntVal（int*x）{
*x=5；
}
无效变更点地址（整数**q）{
int*newad；
*q=newad；
}
无效更改地址（int***q）{
int**假人；
*q=假人；
}
int main（）{
int*p；
国际**pp；
int*tempForPP；
int a=0；
printf（“\n由p->%p，pp->%p，a->%d的值所指向的地址”，p，pp，a）；
p=&a；
pp=&tempForPP；
printf（“\n由p->%p，pp->%p，a->%d的值所指向的地址”，p，pp，a）；
changeIntVal（&a）；//----
//    |---
changePointerAddress（&p）；//----我的意思的一部分
//    |---
changepaddr（&pp）；//----
printf（“\n由p->%p，pp->%p，a->%d的值所指向的地址”，p，pp，a）；
返回0；
}
您正在按值传递指针。如果需要更改poi