C++ C++；传递结构地址

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

但例如：

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

struct stuff
{
整数一
整数二
};
int main{
fnc；
fnc.2=2；
fnc.1=1；
乘法（&fnc）；
}
无效乘法（常数*pm）{
cout one*pm->two；
}

首先……我做得对吗。 其次，为什么在传递函数时使用address操作符，而在实际函数调用中使用*pointer操作符？

---

我很困惑？

当然，除了错误的

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
}

struct stuff
{
int一，二；
};
int main（int argc，const char*argv[]{
fnc；
fnc.2=2；
fnc.1=1；
乘法（&fnc）；//将指针传递给fnc
}
无效乘法（常数*pm）{
//“*”运算符是乘法运算符，而不是指针解引用
cout one*pm->two；//->one等同于（*pm）。one
}

您需要运算符的地址，以便获得对象的地址，从而创建函数期望的指针。参数列表中的“*”不是指针运算符，它只是表示变量是指针。

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

---

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

是的，除了定义

struct stuff

中缺少的分号之外，您的代码是可编译的。关于传递函数和实际函数调用，我不太清楚您到底在问什么，但我想您可能想知道为什么函数调用使用

&fnc

，而参数是

stuff*pm

？在这种情况下，声明的

fnc

变量是一个普通的

stuff

。它不是指针，而是指向该结构的实际实例

现在，

multiply

函数被声明为接受

stuff*

——指向

stuff

的指针。这意味着您不能直接传递

fnc

——它是

东西

，

乘法

需要

*东西

。但是，您可以通过使用&运算符获取地址，将

fnc

作为

stuff*

传递，并且

&fnc

是一个有效的

stuff*

，可以传递到

乘法

---

进入

multiply

函数后，您现在有了一个名为

pm

的

stuff*

。要从这个

东西*

中获取

一个
和
两个
变量，您可以使用指向成员的指针操作符（
->
），因为它们是指向
东西的指针，而不是普通的
东西。在获得这些值（
pm->one
和
pm->two
）后，代码将它们相乘，然后再打印出来（
pm->one*pm->two
）。
下面是一个您希望看到的工作示例

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

#包括
使用名称空间std；
结构材料
{
int-one；
int-2；
};
空乘（空乘*pm）
{
cout one*pm->two；
}
int main（）
{
stuff*fnc=新材料；
fnc->two=1；
fnc->1=2；
乘法（fnc）；
删除fnc；
忽略（1000,10）；
返回0；
}
中的

上面写着“fnc的地址”

当变量声明如下：

下午;

它告诉我们，
pm
应该被视为一个底层类型为
stuff
的地址

如果我们想得到一个变量的地址，我们必须使用

&fnc

*
和
&
操作数的含义不同，这取决于它们是描述类型还是描述变量：

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++实际上没有这些示例，所以不要去寻找它们）：

intx；
指针y=地址of（x）；
参考z=x；
int a=解引用（y）；

这是描述类型和执行操作之间的区别。
您的程序中有几个语法错误，但除此之外，基本思想是正确的。以下是我在编译程序之前必须解决的语法问题：

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

}

在这个函数的定义中，您描述的是一个指向stuff结构的指针。在第一行中，您并不是说要取消对该对象的引用，而是希望有一个指向stuff对象的指针

现在，当您调用乘法时：

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

stuff fnc;
multiply(&fnc);

您正在使用“&”（address of）操作符获取指向该对象的指针。由于multiply函数需要一个指针，而您有一个普通的旧对象，因此需要使用&运算符获取一个指针，以提供给multiply函数

也许更清晰的想法是这样称呼它：

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

以下代码将告诉您有关指针图示的信息

结构地址被传递到名为multiply的函数中
函数使用传递的
结构并将结果存储在结果变量中

你可以在这里看到克莱
void multiply(stuff *fnc) {
...
}

stuff fnc;
multiply(&fnc);

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

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