标签: pass-by-reference

您可以使用关键字"ref"在.NET中执行此操作.有没有办法在Java中这样做？

我试图NSString通过引用传递,但它不起作用.

这是功能:

+(void)fileName:(NSString *) file
{
    file = @"folder_b";
}

这就是电话:

NSString *file;

[function fileName:file];

nslog(@"%@",file);    // and there is nothing in the string....

我必须做什么来通过引用传递我的字符串？

正如标题中所示

我正在尝试编写一个函数来修改由指针传递的原始地图,但Go不允许它.假设我有一张大地图,不想来回复制它.

使用传递值的代码正在工作,正在做我需要的但涉及传递值(playground):

package main

import "fmt"

type Currency string

type Amount struct {
    Currency Currency
    Value float32
}

type Balance map[Currency]float32

func (b Balance) Add(amount Amount) Balance {
    current, ok := b[amount.Currency]
    if ok {
        b[amount.Currency] = current + amount.Value
    } else {
        b[amount.Currency] = amount.Value
    }
    return b
}

func main() {
    b := Balance{Currency("USD"): 100.0}
    b = b.Add(Amount{Currency: Currency("USD"), Value: 5.0})

    fmt.Println("Balance: ", b)
}

但是,如果我尝试将参数传递为像这里的指针(playground):

func (b *Balance) Add(amount Amount) *Balance {
    current, …

我现在真的很困惑如何以及使用哪种方法从函数返回对象.我想要针对给定要求的解决方案提供一些反馈.

场景A:返回的对象将存储在一个变量中,该变量在其生命周期内无需修改.从而,

const Foo SomeClass::GetFoo() {
 return Foo(); 
}

调用为:

someMethod() {
 const Foo& l_Foo = someClassPInstance->GetFoo();
//...
}

Scneraio B:返回的对象将存储在一个变量中,该变量将在其生命周期内被修改.从而,

void SomeClass::GetFoo(Foo& a_Foo_ref) {
     a_Foo_ref = Foo(); 
    }

调用为:

someMethod() {
 Foo l_Foo;
 someClassPInstance->GetFoo(l_Foo);
//...
}

我在这里有一个问题:让我们说Foo不能有默认的构造函数.那么在这种情况下你会怎么处理呢,因为我们不能再写这个了:

Foo l_Foo

场景C:

Foo SomeClass::GetFoo() {
 return Foo(); 
}

调用为:

someMethod() {
 Foo l_Foo = someClassPInstance->GetFoo();
//...
}

我认为这不是推荐的方法,因为它会导致构建额外的临时工.

你怎么看 ？另外,您是否建议使用更好的方法来处理此问题？

在javascript中传递对象及其引用.意味着应该反映任何地方对象的变化.在这种情况下,console.log(a)的预期输出为{}

function change(a,b) {
    a.x = 'added';
    a = b;//assigning a as {} to b
}
a={}
b={}
change(a,b);
console.log(a); //expected {} but output {x:'added'}
console.log(b)

这里发生了什么？据我所知,这不应该是因为功能范围.谢谢

我一直被告知非原始类型应该通过const引用传递,而不是通过值传递,即:

void foo(std::string str);//bad
void foo(const std::string &str);//good

但我今天在想,也许实际上一些简单的用户定义类型实际上可能更好地通过值传递,例如:

class Vector2
{
public:
    float x, y;
    ...constructors, operators overloads, utility methods, etc...
};

void foo(Vector2 pos);
void foo(const Vector2 &pos);//is this really better than by value?
void foo(float x, float y);//after all isn't by value effectively doing this?

我的想法是,通过引用传递Vector2,它实际上比传递值更昂贵,因为编译器现在使用指针和解除引用访问const Vector2&pos版本？

是这样的吗？最简单的对象是否最符合价值？该线应该在哪里绘制？

我正在制作一个从服务器获取文件名列表的方法,但我遇到了一个我无法回答的问题.

该方法返回两件事:

• 一个SftpResult是与各种的返回代码的枚举.
• 文件名列表.

在这三个签名中:

public static ArrayList GetFileList(string directory, out SftpResult result)

public static SftpResult GetFileList(string directory, out ArrayList fileNames)

public static SftpFileListResult GetFileList(string directory)

(其中SftpFileListResult是an SftpResult和an 的复合对象ArrayList)

这是首选,为什么？

我是Cython和C++的菜鸟,所以我对论证传递有一个问题.我想避免在以下场景中传递参数的副本:

# somefile.pyx
#distutils: language = c++
from libcpp.vector cimport vector

def add_one(vector[int] vect):
    cdef int i
    n = vect.size()
    for i in range(n):
        vect[i] += 1

cdef vector[int] v
for i in range(100000):
    v.push_back(i)
add_one(v) # <-- ??

我希望该方法add_one只是修改v"就地".我相信在C++中,你可以通过预先挂起参数来实现这一点&,这意味着对指针的任何更改都会传递给指针.这样,您不必担心传递指针或实际对象,即

add_one(v); # in c++

我可以在Cython中做同样的事情,还是我必须明确地将arg类型更改为引用,即def add_one(vector[int]* vect)？

从C/C++迈出C#世界的第一步,细节上有点模糊.据我所知,类默认通过引用传递,但是例如.列出<string>,如:

void DoStuff(List<string> strs)
{
    //do stuff with the list of strings
}

和其他地方

List<string> sl = new List<string>();
//next fill list in a loop etc. and then do stuff with it:
DoStuff(sl);

是SL在这种情况下按引用传递或者是副本上进行,这样我需要重新定义,如工人功能

void DoStuff(ref List<string> strs)