C++ 指针和传递引用之间的差异_C++

C++ 指针和传递引用之间的差异

c++

C++ 指针和传递引用之间的差异,c++,C++,我对指针和按引用传递有点困惑这是我的密码 int y = 60; int *x = &y; int foo(int &something){ something = 6; return 0; } foo(y); 这是我的问题，若foo取指针的地址，我不应该用foox代替fooy吗 x不是y的地址吗？如果是这样的话，为什么我不能把foox放进去？函数foo不接受指针的地址，甚至不知道你说的是什么意思真的。。。从技术上讲，您可以说fooint**somethi

我对指针和按引用传递有点困惑

这是我的密码

int y = 60;
int *x = &y;

int foo(int &something){
    something = 6;
    return 0;
}

foo(y);

这是我的问题，若foo取指针的地址，我不应该用foox代替fooy吗

x不是y的地址吗？如果是这样的话，为什么我不能把foox放进去？

函数foo不接受指针的地址，甚至不知道你说的是什么意思真的。。。从技术上讲，您可以说fooint**something接受指针的地址

现有函数采用int引用。不要因为在这两种情况下都使用了&符号而心烦意乱。它相似但不同，所需的语法也相应不同。

函数foo不接受指针的地址，甚至不确定这到底是什么意思。。。从技术上讲，您可以说fooint**something接受指针的地址

现有函数采用int引用。不要因为在这两种情况下都使用了&符号而心烦意乱。它相似但不同，所需的语法也相应不同。

如果通过指针传递，则可以使用foox。但是，通过引用传递并不等同于通过指针传递，尽管语法可能会错误地让您认为它们是兼容的。您的函数正在传递某个对象作为引用。如果某个对象是int，则应提供int变量-该对象与指向int的指针不兼容

您可以找到这些机制的更完整的描述。

如果您是通过指针传递的，那么您可以使用foox。但是，通过引用传递并不等同于通过指针传递，尽管语法可能会错误地让您认为它们是兼容的。您的函数正在传递某个对象作为引用。如果某个对象是int，则应提供int变量-该对象与指向int的指针不兼容

您可以找到这些机制的更完整的描述。

foo引用的是一个整数，而不是指针。引用与指针非常相似，因为在幕后传递的是传递给函数的整数的地址。在调用中，传递y变量堆栈上的地址

因为指针也是地址，所以它们是相似的。使用指针时，访问变量的方式会有所不同——使用指针时，需要更加明确

下面的代码与您的代码相同，但使用不同的语法

int foo_pointer(int *pointerToSomething)
{
    *pointerToSomething = 6; // The '*' de-references the pointer, so you are assigning what goes at the address referred to
    return 0;
}
foo_pointer(&y); //to pass the address of you explicitly

通常，指针用于引用动态堆分配的结构或对象，而不是针对您的示例这样的情况

foo引用的是一个整数，而不是指针。引用与指针非常相似，因为在幕后传递的是传递给函数的整数的地址。在调用中，传递y变量堆栈上的地址

因为指针也是地址，所以它们是相似的。使用指针时，访问变量的方式会有所不同——使用指针时，需要更加明确

下面的代码与您的代码相同，但使用不同的语法

int foo_pointer(int *pointerToSomething)
{
    *pointerToSomething = 6; // The '*' de-references the pointer, so you are assigning what goes at the address referred to
    return 0;
}
foo_pointer(&y); //to pass the address of you explicitly

通常，指针用于引用动态堆分配的结构或对象，而不是针对您的示例这样的情况

> P> >查看下面的C++代码< /P>

void foo(int *x){
    *x = 1;
}
void bar(int &x){
    x = 1;
}
int main(){
    int y = 2;
    foo(&y);
    bar(y);
}

这是由g++和命令行参数-S生成的汇编代码

    .file   "main.c"
    .text
    .globl  __Z3fooPi
    .def    __Z3fooPi;  .scl    2;  .type   32; .endef
__Z3fooPi:
    pushl   %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movl    $1, (%eax)
    popl    %ebp
    ret
    .globl  __Z3barRi
    .def    __Z3barRi;  .scl    2;  .type   32; .endef
__Z3barRi:
    pushl   %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movl    $1, (%eax)
    popl    %ebp
    ret
    .def    ___main;    .scl    2;  .type   32; .endef
    .globl  _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $32, %esp
    call    ___main
    movl    $2, 28(%esp)
    leal    28(%esp), %eax
    movl    %eax, (%esp)
    call    __Z3fooPi
    leal    28(%esp), %eax
    movl    %eax, (%esp)
    call    __Z3barRi
    movl    $0, %eax
    leave
    ret

实际上，通过引用传递的概念有其自己的原理，这一点已经被反复提到，但正如您在实现阶段所看到的，重要的是它们是相同的，正如您所看到的，指针和引用都生成了相同的汇编代码。我见过人们在使用“通过引用传递”时遇到问题，因为它没有按照预期的方式实现；所以也许更好，因为它们在实现中是相同的，并且会引起混乱，您可以使用指针，它的根在较低的级别。希望它有帮助：-< /P> < P>查看下面的C++代码< /P>

void foo(int *x){
    *x = 1;
}
void bar(int &x){
    x = 1;
}
int main(){
    int y = 2;
    foo(&y);
    bar(y);
}

这是由g++和命令行参数-S生成的汇编代码

    .file   "main.c"
    .text
    .globl  __Z3fooPi
    .def    __Z3fooPi;  .scl    2;  .type   32; .endef
__Z3fooPi:
    pushl   %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movl    $1, (%eax)
    popl    %ebp
    ret
    .globl  __Z3barRi
    .def    __Z3barRi;  .scl    2;  .type   32; .endef
__Z3barRi:
    pushl   %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movl    $1, (%eax)
    popl    %ebp
    ret
    .def    ___main;    .scl    2;  .type   32; .endef
    .globl  _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $32, %esp
    call    ___main
    movl    $2, 28(%esp)
    leal    28(%esp), %eax
    movl    %eax, (%esp)
    call    __Z3fooPi
    leal    28(%esp), %eax
    movl    %eax, (%esp)
    call    __Z3barRi
    movl    $0, %eax
    leave
    ret

您不能使用foox，因为foo的参数类型是int&，所以您传递的参数应该是int&或int类型的左值。x是int*但x不等于&y吗？那么foox不应该工作吗？不，为什么会？他们是dif

对于不同的类型，指针被初始化为指向y的事实并不意味着它是对y的引用。int&z=y；福兹；之所以有效，是因为现在您有了引用类型，而不是指针。也许将引用作为对象的别名会有所帮助。与指针不同，指针实际占用存储空间，存储空间包含所指向对象的地址，引用只是对象的另一个名称。该语言甚至没有指定如何实现引用。@Pythy-Python：如果foo获取指针的地址，那就没有意义了。foo不接受指针的地址，foo接受引用，这是完全不同的事情。这里没有指针。带有'foox'的想法是完全不相关的。在创建指针时，引用声明中的符号&与&operator绝对没有关系。这只是句法上的巧合，毫无意义。这显然是你困惑的根源。不知何故，您假设int*x=&y中的&y之间存在某种关系；在int-fooint&something中的&something。实际上没有任何关系。不能使用foox，因为foo的参数类型是int&，所以传递的参数应该是int&或int类型的左值。x是int*但x不等于&y吗？那么foox不应该工作吗？不，为什么会？它们是不同的类型，指针被初始化为指向y的事实并不意味着它是对y的引用。int&z=y；福兹；之所以有效，是因为现在您有了引用类型，而不是指针。也许将引用作为对象的别名会有所帮助。与指针不同，指针实际占用存储空间，存储空间包含所指向对象的地址，引用只是对象的另一个名称。该语言甚至没有指定如何实现引用。@Pythy-Python：如果foo获取指针的地址，那就没有意义了。foo不接受指针的地址，foo接受引用，这是完全不同的事情。这里没有指针。带有'foox'的想法是完全不相关的。在创建指针时，引用声明中的符号&与&operator绝对没有关系。这只是句法上的巧合，毫无意义。这显然是你困惑的根源。不知何故，您假设int*x=&y中的&y之间存在某种关系；在int-fooint&something中的&something。事实上根本没有任何关系。好吧，只是不要试图让他们成为你脑海中的一件事，你会有一段轻松得多的时间。好吧，只是不要试图让他们成为你脑海中的一件事，你会有一段轻松得多的时间。