Question

我对将结构传递给函数有点困惑。我理解指针和一切。

但是例如：

struct stuff
{
   int one
   int two 
};

int main{
    stuff fnc;
    fnc.two = 2;
    fnc.one = 1;
    multiply(&fnc);

}

void multiply(const stuff * pm){
    cout << pm->one * pm->two;
}

首先......我甚至做得对。第二，为什么我们在传递函数时使用地址运算符，但在实际函数调用中使用*指针运算符？我很困惑？

Answer 1

是的，您的代码是可编辑的，而不是struct stuff定义中缺少的分号。我不太确定你要求传递函数和实际函数调用，但我想你想知道为什么函数调用使用&fnc，但参数是stuff *pm？在这种情况下，声明的fnc变量是普通stuff。它不是指针，它指的是该结构的实际实例。

现在multiply函数声明为stuff* - 指向stuff的指针。这意味着您无法直接传递fnc - 它是stuff而multiply需要*stuff。但是，您可以使用＆amp ;;将fnc作为stuff*传递。运营商接收地址，&fnc是有效的stuff*，可以传递给multiply。

进入multiply功能后，您现在拥有一个名为stuff*的{{1}}。要从此pm获取one和two变量，请使用指向成员运算符（stuff*）的指针，因为它们是指向->的指针而不是简单的stuff。获取这些值（stuff和pm->one）之后，代码会在将它们打印出来之前将它们相乘（pm->two）。

Answer 2

*和&操作数意味着不同的东西，具体取决于它们是描述类型还是描述变量：

int  x;        // x is an integer
int* y = &x;   // y is a pointer that stores the address of x
int& z =  x;   // z is a reference to x
int  a = *y;   // a in an integer whose value is the deference of y

您的pm变量被声明为指针，因此使用stuff修改了*类型。您正在使用fnc变量（即其地址），因此变量本身标有&。

您可以将上面的示例想象如下（C ++实际上没有这些，所以不要去寻找它们）：

int x;
pointer<int> y = addressof(x);
reference<int> z = x;
int a = dereference(y);

描述类型和执行操作之间的区别。

Answer 3

在

void multiply(const stuff * pm){
    cout << pm->one * pm->two;
}

stuff * pm表示pm是一个东西结构的地址。

在

&fnc

说“fnc”的地址。

当变量声明为：

时

东西* pm;

它告诉我们pm应该被视为基础类型为stuff的地址。

如果我们想获取变量stuff fnc的地址，我们必须使用

＆安培; FNC

Answer 4

当然，除了错误的main函数定义之外，这还可行。

这可行的原因是因为当你使用一元&运算符时，它本质上会返回一个指向操作数的指针，所以在你的情况下，fnc，类型为stuff }，如果您执行&fnc，则会返回stuff *。这就是multiply函数必须采用stuff *。

的原因

struct stuff
{
   int one, two;
};

int main(int argc, const char* argv[]) {
    stuff fnc;
    fnc.two = 2;
    fnc.one = 1;
    multiply(&fnc); //passes a pointer to fnc
}

void multiply(const stuff * pm){
    //the "*" operator is the multiplication operator, not a pointer dereference
    cout << pm->one * pm->two; //->one is equivalent to (*pm).one
}

Answer 5

你需要操作符的地址，这样你就可以得到对象的地址，创建一个函数所需的指针。参数列表中的'*'不是指针运算符，它只是表示变量是指针。

Answer 6

您的代码是正确的。在主要方面，您成功创建了一个'stuff'对象并设置其值。然后，将常量地址传递给对象到函数multiply中。然后乘法函数使用该地址访问结构的两个变量，以输出变量的乘法。

“const stuff * pm”中的*表示它需要一个指向stuff对象的常量指针。

Answer 7

以下是您希望看到的实例。

#include <iostream>
using namespace std;
struct stuff
{
   int one;
   int two;
};

void multiply(stuff* pm)
{
    cout << pm->one * pm->two;
}
int main()
{
    stuff* fnc = new stuff;
    fnc->two = 1;
    fnc->one = 2;
    multiply(fnc);
    delete fnc;
    cin.ignore(1000, 10);
    return 0;
}

Answer 8

你的程序中有几个语法错误，但除此之外，基本的想法很好。以下是在程序编译之前我必须解决的语法问题：

#include <iostream>

using namespace std;

struct stuff
{
   int one;
   int two; 
};

void multiply(const stuff * pm) {
    cout << pm->one * pm->two;
}

int main() {
    stuff fnc;
    fnc.two = 2;
    fnc.one = 1;
    multiply(&fnc);

}

回答有关'＆amp;'之间差异的问题（地址）运算符和'*'（指针取消引用）运算符，我们只需要考虑你传入函数的类型。

将函数乘以：

void multiply(stuff *fnc) {
...
}

在这个函数的定义中，你描述的是一个指向stuff结构的指针。在第一行中，您并不是说您正在取消引用该对象，只是因为您期望指向一个东西对象。

现在当你调用multiply：

stuff fnc;
multiply(&fnc);

您正在使用'＆amp;' （地址）运算符获取指向对象的指针。由于乘法函数需要一个指针，而你有一个普通的旧对象，你需要使用＆amp;运算符以获取指向赋予乘法函数的指针。

或许更清楚地认为这样称呼：

stuff fnc; //The actual object
stuff* fnc_ptr = &fnc; //A pointer to a stuff object, initialized to point at fnc created above
multiply(fnc_ptr); //Call the function with the pointer directly

Answer 9

以下代码会告诉您指针插图

将结构地址传递给名为multiply的函数函数使用传递的元素执行一些操作结构并将结果存储在结果变量中。

你可以清楚地看到结果变量先前是零然后在将结构的地址传递给函数后，结果变量值被更新为值 6 。这就是指针的工作原理。

#include <iostream.h>



struct stuff
{
   int one;
   int two ;
   int result;
};
void multiply(stuff *pm);
int main(){
    stuff fnc;
    fnc.two = 2;
    fnc.one = 3;
    fnc.result = 0;
    multiply(&fnc);
    cout<<fnc.result;

return 0;

}

void multiply(stuff *pm)
{
    pm->result = pm->one * pm->two;
}

C ++传递结构地址

9 个答案: