标签: ref

我正在创建一个函数,我需要传递一个对象,以便它可以被函数修改.有什么区别:

public void myFunction(ref MyClass someClass)

和

public void myFunction(out MyClass someClass)

我应该使用哪个以及为什么？

如果我将对象传递给方法,为什么要使用ref关键字？这不是默认行为吗？

例如:

class Program
{
    static void Main(string[] args)
    {
        TestRef t = new TestRef();
        t.Something = "Foo";

        DoSomething(t);
        Console.WriteLine(t.Something);
    }

    static public void DoSomething(TestRef t)
    {
        t.Something = "Bar";
    }
}


public class TestRef
{
    public string Something { get; set; }
}

输出为"Bar",表示该对象作为参考传递.

是否可以使用Moq(3.0+)分配out/ ref参数？

我看过使用Callback(),但Action<>不支持ref参数,因为它基于泛型.我也最好It.Is在ref参数的输入上放置一个约束(),尽管我可以在回调中做到这一点.

我知道Rhino Mocks支持这个功能,但我正在研究的项目已经在使用Moq了.

我有一个对象是我在程序的内存状态,还有一些其他的工作函数,我传递对象来修改状态.我已经通过ref传递给工人函数了.但是我遇到了以下功能.

byte[] received_s = new byte[2048];
IPEndPoint tmpIpEndPoint = new IPEndPoint(IPAddress.Any, UdpPort_msg);
EndPoint remoteEP = (tmpIpEndPoint);

int sz = soUdp_msg.ReceiveFrom(received_s, ref remoteEP); 

它混淆了我,因为两者received_s并remoteEP从函数返回的东西.为什么remoteEP需要一个ref而received_s不是一个？

我也是程序员,所以我有一个问题,我的头脑中有指针.

编辑:看起来C#中的对象是引导下对象的指针.因此,当您将对象传递给函数时,您可以通过指针修改对象内容,传递给函数的唯一内容是指向对象的指针,因此对象本身不会被复制.如果您希望能够在函数中切换或创建一个新对象,就像双指针一样,则使用ref或out.

我对这个程序有一些疑问:

#include <iostream>
#include <type_traits>
#include <functional>
using namespace std;
template <typename T> void foo ( T x )
{
    auto r=ref(x);
    cout<<boolalpha;
    cout<<is_same<T&,decltype(r)>::value;
}
int main()
{
    int x=5;
    foo (x);
    return 0;
}

输出是:

false

我想知道,如果std::ref没有返回对象的引用,那么它会做什么？基本上,有什么区别:

T x;
auto r = ref(x);

和

T x;
T &y = x;

另外,我想知道为什么存在这种差异？为什么我们需要std::ref或std::reference_wrapper什么时候有参考(即T&)？

考虑以下代码:

#include <iostream>
#include <functional>

int xx = 7;

template<class T>
void f1(T arg)
{
    arg += xx;
}

template<class T>
void f2(T arg)
{
    arg = xx;
}

int main()
{
    int j;

    j=100;
    f1(std::ref(j));
    std::cout << j << std::endl;

    j=100;
    f2(std::ref(j));
    std::cout << j << std::endl;
}

执行时,此代码输出

107
100

我原以为第二个值是7而不是100.

我错过了什么？

有人可以举一个简单的例子来证明其功能std::ref吗？我的意思是一个例子,其中只有在std::ref没有它们的情况下无法解释时才使用其他一些结构(如元组或数据类型模板).

我在std::ref 这里和这里找到了两个问题.但是在第一个中,它涉及编译器中的错误,而在第二个中,使用std::ref不包含的示例,std::ref它们涉及元组和数据类型模板,这使得对这些示例的理解变得复杂.

这是一个简单的控制台应用程序代码,它返回一个我完全不理解的结果.

试着想一想它是否在控制台中输出0,1或2:

using System;

namespace ConsoleApplication
{
    class Program
    {
        static void Main()
        {
            int i = 0;
            i += Increment(ref i);

            Console.WriteLine(i);
            Console.ReadLine();
        }

        static private int Increment(ref int i)
        {
            return i++;
        }
    }
}

答案是0.

我不明白的是为什么i++从Increment方法上执行的post增量ref(不是在传递的变量的副本上)确实增加了变量,但它稍后会被忽略.

我的意思是在这个视频中:

有人可以解释这个例子以及为什么在调试期间我看到该值增加到1,但它又回到0？

事实证明,引用本地资源可能是一些人的问题.我正在寻找本地资源引用的规范答案,以及它们的含义.

举几个例子,这些参考路径有什么区别？

• <img src="myfile.png" /> (没有领先的斜线)
• <img src="/myfile.png" /> (带斜线)
• <img src="folder/myfile.png" /> (子文件夹中没有前导斜杠)
• <img src="/folder/myfile.png" /> (带有斜杠/子文件夹)
• <img src="../folder/myfile.png" /> (带点和前导斜杠/在子文件夹中)

我正在尝试创建一个可以创建一个Action的函数来增加传入的整数.但是我的第一次尝试是给出了一个错误"不能在匿名方法体内使用ref或out参数".

public static class IntEx {
    public static Action CreateIncrementer(ref int reference) {
        return () => {
            reference += 1;
        };
    }
}

我理解为什么编译器不喜欢这个,但是我希望有一个优雅的方法来提供一个可以指向任何整数的漂亮的增量器工厂.我看到这样做的唯一方法如下:

public static class IntEx {
    public static Action CreateIncrementer(Func<int> getter, Action<int> setter) {
        return () => setter(getter() + 1);
    }
}

但当然这对来电者来说更是一种痛苦; 要求调用者创建两个lambda而不是仅仅传入一个引用.有没有更优雅的方式来提供这个功能,或者我只需要忍受双lambda选项？