C# 将ref与类C一起使用#
我想给我正在制作的一个类提供一个特定的链表。我希望类写入该列表（例如by.addLast（）） 我应该使用C# 将ref与类C一起使用#,c#,pointers,reference,keyword,C#,Pointers,Reference,Keyword,我想给我正在制作的一个类提供一个特定的链表。我希望类写入该列表（例如by.addLast（）） 我应该使用ref关键字吗 我对C#中的ref和out关键字在何处使用感到有些困惑，因为所有类都是在堆上动态分配的，我们实际上对大多数操作都使用指针。 当然，out和ref关键字对于原语和结构是有意义的 另外，如果我不直接发送列表，而是发送一个包含该列表的类？（它是internal并且是必需的），我还需要使用ref？或者如果我在函数之间传递它，例如： void A(ref LinkedList<i
refrefout当然，
outrefinternalrefvoid A(ref LinkedList<int> list){
B(list);
}
void B(ref LinkedList<int> list){
_myList = list;
}
void A（参考链接列表）{
B（名单）；
}
无效B（参考链接列表）{
_myList=列表；
}
listrefoutref对象o也可能有助于您理解。这是对C#中使用
refrefout总结：在阅读了我的回复和Jon Skeet的文章之后，我希望您会发现，在您的问题中没有必要使用
refvoid methodA(string test)
{
test = "Hello World";
}
void methodB(ref string test)
{
test = "Hello World";
}
void Runner()
{
string first= "string";
methodA(first);
string second= "string";
methodB(ref second);
Console.WriteLine((first == second).ToString()); //this would print false
}
如果要在函数中创建新对象，则只需将ref与引用类型一起使用 示例#1：
ref// ...
List myList = new List();
PopulateList(myList);
// ...
void PopulateList(List AList)
{
AList.Add("Hello");
AList.Add("World");
}
// ...
List myList;
PopulateList(ref myList);
// ...
void PopulateList(ref List AList)
{
AList = new List();
AList.Add("Hello");
AList.Add("World");
}
ref// ...
List myList = new List();
PopulateList(myList);
// ...
void PopulateList(List AList)
{
AList.Add("Hello");
AList.Add("World");
}
// ...
List myList;
PopulateList(ref myList);
// ...
void PopulateList(ref List AList)
{
AList = new List();
AList.Add("Hello");
AList.Add("World");
}
<>我为C++程序员添加了这个答案，就像我自己一样。 类、接口、委托和数组都是
引用类型//C# code:
void Foo(ClassA input)
void Bar(ClassA ref input)
//equivalent C++ code:
void Foo(ClassA* input)
void Bar(ClassA*& input)
//C# code:
void Foo(StructA input)
void Bar(StructA ref input)
//equivalent C++ code:
void Foo(StructA input)
void Bar(StructA& input)
ref//C# code:
void Foobar(ClassB ref input)
...
ClassB instance = new ClassB();
Foobar(ref instance);
//equivalent C++ code:
void Foobar(ClassB*& input)
...
ClassB instance* = new ClassB();
Foobar(instance);
有趣的是，通过引用调用可以与底层指针一起工作，因此我们将看到以下代码：
//C# code:
void Foo(ClassA input){
input = input + 3;
}
void Bar(ClassA ref input){
input = input + 3;
}
//equivalent C++ code:
void Foo(ClassA& input){
input = input + 3;
}
void Bar(ClassA*& input){
*input = *input + 3;
}
//equivalent pure C code:
void Fun(ClassA* input){
*input = *input + 3;
}
void Fun(ClassA** input){
*(*input) = *(*input) + 3;
}
这是一个粗略的等价物，但有点真实。我知道这是一个老问题，但在我看来，没有一个答案能给出很好的直接原因 在本例中不需要使用
refvoid Foo(MyClass a1, ref MyClass a2, out MyClass b1, int c1, MyStruct d1, ref MyStruct d2)
{
}
void Foo(MyClass a1, ref MyClass a2,
out MyClass b1,
int c1,
MyStruct d1, ref MyStruct d2)
{
a1 is a copy in memory of the pointer to the instantiated class a;
a2 is the pointer to the instantiated class a;
b1 is the pointer to b, but has the additional check of having to be set within this function - and cannot be used before being set;
c1 is a copy in memory of the variable c;
d1 is a copy in memory of the struct d;
d2 is the struct d;
}
MyClass a = new MyClass();
MyClass b = null
int c = 3;
MyStruct d = new MyStruct();
Foo(a, ref a, b, c, d, ref d);
void Foo(MyClass a1, ref MyClass a2, out MyClass b1, int c1, MyStruct d1, ref MyStruct d2)
{
}
void Foo(MyClass a1, ref MyClass a2,
out MyClass b1,
int c1,
MyStruct d1, ref MyStruct d2)
{
a1 is a copy in memory of the pointer to the instantiated class a;
a2 is the pointer to the instantiated class a;
b1 is the pointer to b, but has the additional check of having to be set within this function - and cannot be used before being set;
c1 is a copy in memory of the variable c;
d1 is a copy in memory of the struct d;
d2 is the struct d;
}
a1nullanulla2nullanull