C# ref это как указатель на C / C++ или ссылка на C++?

В C#, когда вы видите что-то, относящееся к ссылочному типу (то есть типу, объявленному с class вместо struct), то вы по существу всегда имеете дело с объектом через указатель. В C++ все по умолчанию является типом значения, тогда как в C# все по умолчанию является ссылочным типом.

когда вы говорите " ref "в списке параметров C#, то, что вы действительно говорите, больше похоже на "указатель на указатель"."Вы говорите, что в методе, который вы хотите заменить не содержимое объекта, а ссылка на сам объект в коде, вызывающем ваш метод.

если это не ваше намерение, то вы должны просто передать ссылочный тип напрямую; в C# передача ссылочных типов дешева (сродни передаче ссылки в C++).

узнать/понять разницу между типами значений и ссылочными типами в C#. Они являются основной концепцией на этом языке, и все будет очень запутанным, если вы попытаетесь думать, используя объектная модель C++ в C# land.

следующие по существу семантически эквивалентные программы:

#include <iostream>

class AClass
{
    int anInteger;
public:
    AClass(int integer)
        : anInteger(integer)
    {  }

    int GetInteger() const
    {
        return anInteger;
    }

    void SetInteger(int toSet)
    {
        anInteger = toSet;
    }
};

struct StaticFunctions
{
    // C# doesn't have free functions, so I'll do similar in C++
    // Note that in real code you'd use a free function for this.

    static void FunctionTakingAReference(AClass *item)
    {
        item->SetInteger(4);
    }

    static void FunctionTakingAReferenceToAReference(AClass **item)
    {
        *item = new AClass(1729);
    }
};

int main()
{
    AClass* instanceOne = new AClass(6);
    StaticFunctions::FunctionTakingAReference(instanceOne);
    std::cout << instanceOne->GetInteger() << "\n";

    AClass* instanceTwo;
    StaticFunctions::FunctionTakingAReferenceToAReference(&instanceTwo);
    // Note that operator& behaves similar to the C# keyword "ref" at the call site.
    std::cout << instanceTwo->GetInteger() << "\n";

    // (Of course in real C++ you're using std::shared_ptr and std::unique_ptr instead,
    //  right? :) )
    delete instanceOne;
    delete instanceTwo;
}

и для C#:

using System;

internal class AClass
{
    public AClass(int integer)
        : Integer(integer)
    {  }

    int Integer { get; set; }
}

internal static class StaticFunctions
{
    public static void FunctionTakingAReference(AClass item)
    {
        item.Integer = 4;
    }

    public static void FunctionTakingAReferenceToAReference(ref AClass item)
    {
        item = new AClass(1729);
    }
}

public static class Program
{
    public static void main()
    {
        AClass instanceOne = new AClass(6);
        StaticFunctions.FunctionTakingAReference(instanceOne);
        Console.WriteLine(instanceOne.Integer);

        AClass instanceTwo  = new AClass(1234); // C# forces me to assign this before
                                                // it can be passed. Use "out" instead of
                                                // "ref" and that requirement goes away.
        StaticFunctions.FunctionTakingAReferenceToAReference(ref instanceTwo);
        Console.WriteLine(instanceTwo.Integer);
    }
}