【问题标题】:Store a reference to an object存储对对象的引用
【发布时间】:2012-10-28 21:18:00
【问题描述】:

有点奇怪的问题,但我想知道有人可以帮忙......

在 C++ 中,我可以做这样的事情

class MyOtherClass
{
     private:
         MyLogger* logger;
     public:
         MyOtherClass (MyLogger* logger)
              : logger (logger)
         {}
};

class MyClass
{
     private:
         MyLogger* logger;
     public:
         MyClass (MyLogger* logger)
              : logger (logger)
         {}
};

int main (int c, char** args)
{
    MyLogger* logger = new MyLogger ();
    /* Code to set up logger */
    MyOtherClass* myOtherClass = new MyOtherClass (logger);
    MyClass* myClass = new MyClass (logger);
}

这样每个其他对象(myOtherClass 和 myClass)都将包含指向记录器的指针,因此它们将调用相同的记录器类。但是,我将如何在 C# 中实现相同的目标?有没有办法存储指向全局对象的引用或指针 - 我猜如果我在 C# 中执行类似的操作

public class MyClass
{
     private MyLogger logger = null;

     public MyClass (MyLogger _logger)
     {
         logger = _logger;
     }
};

它实际上将类变量 logger 分配给 _logger 的副本?还是我把事情搞混了:S

非常感谢任何帮助,并提前感谢您!

【问题讨论】:

标签: c# c++


【解决方案1】:

在 C# 中实际上要简单得多。

基本上,您可以这样做:

MyLogger logger = new MyLogger();
MyOtherClass myOtherClass = new MyOtherClass(logger);
MyClass myClass = new MyClass(logger);

在 C# 中,类基本上是作为引用保存的(实际上只是底层的指针)。在这个 sn-p 中,您将 reference 到 logger 传递给两个对象的构造函数。该引用是相同的,因此每个实例都有相同的MyLogger 实例。

在这种特殊情况下,您几乎只需要删除指针语法 =D

【讨论】:

  • 是的,我本来以为是这样的,但后来我觉得不可能那么容易!假设当您更多地使用 C++ 而不是 C# 时会发生这种情况:P
  • 是的。与 C++ 相比,一个基本的问题是对象变量实际上是引擎盖下的指针......主要是。当然总是例外=D
  • 啊对,所以基本上在 C# 中 MyLogger logger = new MyLogger () 是 C++ MyLogger* logger = new MyLogger () 的等价物?
  • 您不需要任何特殊修饰符。从技术上讲,所有引用按值传递,这意味着指针值被复制并传入,但它仍然是对实际实例的引用。 ref 仅在您想通过引用传递您的对象指针时才需要,为该方法提供对您的实例的实际引用。通常,当您希望在方法中更改对实例的引用时会使用它。当按值传递时,您的方法可以在内部分配一个新的引用,但在该方法的范围之外,实际的引用并没有改变。
  • @SCassidy1986 使用 ref 将有 C++ 等价的传递指向对象指针的指针。如果这确实是您所需要的(即您需要能够更改函数中指针指向的内容,而不是改变底层对象),那就这样吧。不过这种情况很少见。
【解决方案2】:

你把事情搞混了。在 C# 中,赋值语句如

    logger = _logger;

复制引用,而不是对象。在这条语句执行之后,仍然(最多)只有一个MyLogger - 它现在被两个对象变量引用。

【讨论】:

  • 啊,是的,我现在明白了,我对 C# 有点陌生,正在使用 C++,但我似乎忘记了 C# :(
【解决方案3】:

如果类型是引用类型(类就是这种情况),那么您将复制引用,而不是对象本身。

与引用类型相反,你有值类型。值类型基本上是基本类型:int、double 等

在您的情况下,这意味着您将使用相同的对象,无论您是从类还是从外部调用方法访问它。这是因为您的目标是引用的对象。

【讨论】:

  • string 是一个引用类型。
  • 它实际上表现为一个值类型。如果将字符串传递给方法,并且在此方法中更新字符串,则调用方法的参数值将保持不变。这里某处,Eric Lippert explained this decision。
  • 我不知道你在说什么:你不能改变字符串根本。
  • 这是一件好事。我想说的是,如果您调用string s = "hello";SomeMethod(s);" s`,无论使用参数做什么,都将始终是“Hello”。
  • 是的,这意味着“如果你在这个方法中更新字符串”是没有意义的。
【解决方案4】:

为将来的我添加评论,因为有时我也忘记了,同样对于 c# 中的新手想要可视化“c++ 指针”与“c# 对象引用”与“C# 对象引用 By Ref”。 注意 Passing By Ref(Last method call) 和分配新的 obj 是如何改变原始对象的。

using System;

public class Emp
{
    public int TimeSpentInCompany {get; set;}
}

public class Program
{
    public static void Main()
    {
        
        Emp t1 = new Emp{TimeSpentInCompany = 5};
        Console.WriteLine("original obj before method call-->" + t1.TimeSpentInCompany);
        
        // Test is one by one
        
        // var res = PassObject_SimpleUpdateMemberAndPrint(t1);
        // var res = PassObject_SimpleUpdateObjectAndPrint(t1);
        // var res = PassObjectByRef_SimpleUpdateMemberAndPrint(ref t1);
        var res = PassObjectByRef_SimpleUpdateObjectAndPrint(ref t1);
        
        Console.WriteLine("original obj after method call-->" + t1.TimeSpentInCompany);
        Console.WriteLine("obj from method response-->" + res.TimeSpentInCompany);
    }
    
    static Emp PassObject_SimpleUpdateMemberAndPrint(Emp data)
    {
        /*
            original obj before method call-->5
            in method before modification obj member--> 5
            in method AFTER modification obj member--> 9
            original obj after method call-->9
            obj from method response-->9
        */      
        Console.WriteLine("in method before modification obj member--> "+ data.TimeSpentInCompany);
        data.TimeSpentInCompany += 4;
        Console.WriteLine("in method AFTER modification obj member--> "+ data.TimeSpentInCompany);
        return data;
    }   
    
    static Emp PassObject_SimpleUpdateObjectAndPrint(Emp data)
    {
        /*
            original obj before method call-->5
            in method before assigning new obj --> 5
            in method AFTER assigning new obj --> 9
            original obj after method call-->5
            obj from method response-->9
        */
        Console.WriteLine("in method before assigning new obj --> "+ data.TimeSpentInCompany);
        data = new Emp{TimeSpentInCompany = 9};
        Console.WriteLine("in method AFTER assigning new obj --> "+ data.TimeSpentInCompany);
        return data;
    }
    
    static Emp PassObjectByRef_SimpleUpdateMemberAndPrint(ref Emp data)
    {
        /*
            original obj before method call-->5
            in method before modification obj member--> 5
            in method AFTER modification obj member--> 9
            original obj after method call-->9
            obj from method response-->9
        */      
        Console.WriteLine("in method before modification obj member--> "+ data.TimeSpentInCompany);
        data.TimeSpentInCompany += 4;
        Console.WriteLine("in method AFTER modification obj member--> "+ data.TimeSpentInCompany);
        return data;
    }   
    
    static Emp PassObjectByRef_SimpleUpdateObjectAndPrint(ref Emp data)
    {
        /*
            original obj before method call-->5
            in method before assigning new obj --> 5
            in method AFTER assigning new obj --> 9
            original obj after method call-->9
            obj from method response-->9
        */
        Console.WriteLine("in method before assigning new obj --> "+ data.TimeSpentInCompany);
        data = new Emp{TimeSpentInCompany = 9};
        Console.WriteLine("in method AFTER assigning new obj --> "+ data.TimeSpentInCompany);
        return data;
    }
}

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2020-05-24
    • 2014-02-16
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2016-06-16
    相关资源
    最近更新 更多