C++ 将指针传递给函数 (Howto) + C++ 指针操作

Question

我对传递指针的工作原理有点困惑。

假设我有以下函数和指针，并且...

编辑：

...我想在函数中使用指向某个对象的指针作为参数。

即：

void Fun(int Pointer){
    int Fun_Ptr = ---Passed Pointer---; 
    //So that Fun_Ptr points to whatever ---Passed Pointer points to

在 *Pointer 和 &Pointer 符号之间，我很困惑。我知道 *Pointer 意味着给出它所指向的任何东西。

我是否将 void (int *pointer) 放入声明中。那我用这个功能的时候呢？

感谢您的帮助。

编辑 2：

好的，我现在明白在声明中使用 *variable 意味着将传递一个指针。但是，当我使用该功能时呢？

即

int main(){
    int foo;
    int *bar;
    bar = foo;
    Fun(bar);
}

编辑 3： 好的，如果我错了，请纠正我：

根据上面代码的约定：

bar = &foo 表示：让 bar 指向内存中的 foo

*bar = foo 表示将 bar 指向的值更改为等于 foo 等于的值

如果我有第二个指针（int *oof），那么：

bar = oof 表示：bar 指向 oof 指针

bar = *oof 表示：bar 指向 oof 指向的值，而不是指向 oof 指针本身

*bar = *oof 意思是：把bar指向的值改成oof指向的值

&bar = &oof 意思是：把bar指向的内存地址改成和oof指向的内存地址一样

我有这个权利吗？

编辑 4：非常感谢您的所有帮助（我希望我能接受超过 1 个答案，但我必须选择第一个答案。我不确定社区 wiki 是如何工作的，但我会留下它以这种方式进行编辑（如果您愿意，可以随意将其变成参考指南）。

Answer 1

定义变量和使用变量时 * 的用法有所不同。

在声明中，

int *myVariable;

表示指向整数数据类型的指针。然而在使用中，

*myVariable = 3;

意味着取消引用指针并使其指向的结构等于3，而不是使指针等于内存地址0x 0003。

所以在你的函数中，你想这样做：

void makePointerEqualSomething(int* pInteger)
{
    *pInteger = 7;
}

在函数声明中，* 表示您正在传递一个指针，但在其实际代码体中 * 表示您正在访问指针所指向的内容。

为了消除您的困惑，我将简要介绍与号 (&)

& 表示获取某物的地址，它在计算机内存中的确切位置，所以

 int & myVariable;

在声明中表示整数或指针的地址！

不过这个

int someData;    
pInteger = &someData;

意味着使 pInteger 指针本身（记住，指针只是它们指向的内存地址）等于“someData”的地址 - 所以现在 pInteger 将指向一些数据，并且可以在您访问它时使用尊重它：

*pInteger += 9000;

这对你有意义吗？还有什么让您感到困惑的地方吗？

@Edit3：

几乎正确，除了三个陈述

bar = *oof;

表示bar指针等于一个整数，而不是bar指向的那个，无效。

&bar = &oof;

& 符号就像一个函数，一旦它返回一个内存地址，你就无法修改它的来源。就像这段代码：

returnThisInt("72") = 86; 

无效，你的也是。

最后，

bar = oof

并不意味着“bar 指向 oof 指针”。相反，这意味着 bar 指向 oof 指向的地址，因此 bar 指向 foo 所指向的任何地址 - 而不是 bar 指向 foo 指向的 oof。

Answer 2

要声明一个带有指向 int 的指针的函数：

void Foo(int *x);

要使用这个功能：

int x = 4;
int *x_ptr = &x;
Foo(x_ptr);
Foo(&x);

如果你想要一个指向另一种类型对象的指针，也差不多：

void Foo(Object *o);

但是，您可能更喜欢使用引用。它们比指针更容易混淆：

// pass a reference
void Foo(int &x)
{
  x = 2;
}

//pass a pointer
void Foo_p(int *p)
{
   *x = 9;
}

// pass by value
void Bar(int x)
{
   x = 7;
}
int x = 4;
Foo(x);  // x now equals 2.
Foo_p(&x); // x now equals 9.
Bar(x);  // x still equals 9.

使用引用，您仍然可以更改传递给函数的 x（就像使用指针一样），但您不必担心取消引用或操作地址。

根据其他人的建议，查看C++FAQLite。这是一个很好的资源。

编辑 3 回复：

bar = &foo 表示：让 bar 指向内存中的 foo

是的。

*bar = foo 表示将 bar 指向的值更改为等于 foo 等于的值

是的。

如果我有第二个指针（int *oof），那么：

bar = oof 表示：bar 指向 oof 指针

bar 将指向任何 oof 指向的内容。它们都会指向同一个东西。

bar = *oof 表示：bar 指向 oof 指向的值，而不是指向 oof 指针本身

没有。你不能这样做（假设 bar 是 int * 类型）你可以制作指针指针。 (int **)，但我们不要讨论这个......你不能将指针分配给一个 int（嗯，你可以，但这是一个不符合讨论的细节）。 p>

*bar = *oof 意思是：把bar指向的值改成oof指向的值

是的。

&bar = &oof 意思是：把bar指向的内存地址改成和oof指向的内存地址一样

没有。您不能这样做，因为运算符的地址返回一个右值。基本上，这意味着你不能给它分配东西。

Answer 3

要传递一个指向 int 的指针，它应该是 void Fun(int* pointer)。

传递对 int 的引用看起来像这样...

void Fun(int& ref) {
   ref = 10;
}

int main() {
   int test = 5;
   cout << test << endl;  // prints 5

   Fun(test);
   cout << test << endl;  // prints 10 because Fun modified the value

   return 1;
}

Answer 4

如果你想将一个指向 int 的指针传递给你的函数，

功能声明（如果需要）：

void Fun(int *ptr);

函数定义：

void Fun(int *ptr) {
    int *other_pointer = ptr;  // other_pointer points to the same thing as ptr
    *other_ptr = 3;            // manipulate the thing they both point to
}

函数的使用：

int main() {
    int x = 2;
    printf("%d\n", x);
    Fun(&x);
    printf("%d\n", x);
}

请注意，作为一般规则，名为Ptr 或Pointer 的变量永远不应具有int 类型，这就是您在代码中的类型。指向 int 的指针的类型为 int *。

如果我有第二个指针（int *oof）， 那么：

bar = oof 表示：bar 指向 oof 指针

意思是“让 bar 指向 oof 指向的东西”。

bar = *oof 表示：bar 指向 oof 指向但不指向的值 oof 指针本身

这没有任何意义，它是无效的。 bar 是一个指针 *oof 是一个 int。您不能将一个分配给另一个。

*bar = *oof 表示：将 bar 指向的值更改为 oof 指向

是的。

&bar = &oof 表示：改变内存 栏指向的地址相同 作为 oof 指向的内存地址 到

不，这又是无效的。 &bar 是一个指向 bar 变量的指针，但它是所谓的“右值”或“临时”，它不能被赋值。这就像算术计算的结果。你不能写x + 1 = 5。

将指针视为地址可能会对您有所帮助。 bar = oof 表示“make bar，是地址，等于oof，也是地址”。 bar = &foo 表示“make bar，是一个地址，等于 foo 的地址”。如果bar = *oof 有任何含义，则表示“make bar，它是一个地址，等于*oof，它是一个int”。你不能。

那么，& 是地址运算符。它的意思是“操作数的地址”，所以&foo 是 foo 的地址（即指向 foo 的指针）。 * 是取消引用运算符。它的意思是“操作数给出的地址处的东西”。所以完成了bar = &foo，*bar 是foo。

Answer 5

void Fun(int *Pointer)
{
  //if you want to manipulate the content of the pointer:
  *Pointer=10;
  //Here we are changing the contents of Pointer to 10
}

* 在指针前表示指针的内容（声明中除外！）

&在指针（或任何变量）之前表示地址

编辑：

int someint=15;
//to call the function
Fun(&someint);
//or we can also do
int *ptr;
ptr=&someint;
Fun(ptr);

Answer 6

void Fun(int* Pointer)   -- would be called as Fun( &somevariable )

将允许您通过在 Fun 函数中取消引用来操纵“指针”指向的内容，即

*Pointer = 1;

如上声明它还允许您操作超出其指向的数据：

int foo[10] = {0};
Fun(foo);

在函数中你可以像 *(Pointer + 1) = 12;设置数组的第二个值。

void Fun(int& Pointer)  -- would be called Fun( somevariable )

您可以修改 Pointer 引用的内容，但在这种情况下，您无法访问 Pointer 引用的内容之外的任何内容。

Answer 7

使用更简洁、更强大的 Functionoid 可能会让您更容易理解，请参阅此优秀且强烈推荐的 C++ FAQ lite，尤其是从第 33.12 节开始，但尽管如此，请从头开始阅读了解该部分的内容。

回答你的问题：

typedef void (*foobar)() fubarfn;

void Fun(fubarfn& baz){
   fubarfn = baz;
   baz();
}

编辑：

• & 表示参考地址
• * 表示引用地址中包含的值，称为去引用

所以使用引用，下面的例子，说明我们是传入一个参数，直接修改它。

void FunByRef(int& iPtr){
    iPtr = 2;
}

int main(void){
    // ...
    int n;
    FunByRef(n);
    cout << n << endl; // n will have value of 2
}