标签: encapsulation

我想在我的程序中使用Eigen矩阵库作为线性代数引擎.Eigen使用表达式模板来实现延迟评估并简化循环和计算.

例如:

#include<Eigen/Core>

int main()
{
  int size = 40;
  // VectorXf is a vector of floats, with dynamic size.
  Eigen::VectorXf u(size), v(size), w(size), z(size);
  u = 2*v + w + 0.2*z;
}

由于Eigen使用表达式模板,代码如

u = 2*v + w + 0.2*z;

在上面提到的样品中,减少到长度为10的单个环(不是40,浮子被4个块放入调节器中)而不会产生临时的.多么酷啊？

但如果我像这样集成库:

class UsingEigen
{
    public:  
        UsingEigen(const Eigen::VectorXf& data):
            data_(data)
        {}

        UsingEigen operator + (const UsingEigen& adee)const
        {
            return UsingEigen(data_ + adee.data_);
        }

        ...
    private:
        Eigen::VectorXf data_;
}

那么表达式就像:

UsingEigen a, b, c, d;
a = b + c …

我有一个对象,我想在创建后才能读取...因为构造函数中的属性必须在GetHashCode中使用,因此一旦创建就不能更改.

我是readonly的许多类之一:

public class AccountLabel
{ 
    private string result;

    public AccountLabel(string result)
    {
        // TODO: Complete member initialization
        this.result = result;
    }

    public string JSONRPCData { get { return this.result; } }
}

我有这样的通用结果类

  public  class JsonResult<T>  where  T : JObject, new()
  {
    private T bhash;
    private string p;
    private JsonErrorResponse error;
    private int _id;
    private Newtonsoft.Json.Linq.JObject ret;

    public JsonResult(Newtonsoft.Json.Linq.JObject ret)
    { 
        this.ret = ret;

        var tempError = ret["error"];
        var tempid = ret["id"];
        JsonErrorResponse error = new JsonErrorResponse(tempError);
        this.error = …

如果您的公共界面中有属性,如下所示

@interface MyClass : NSObject
@property(strong) NSString *myProp;
@end

然后合成它,实际上合成变量:

@implementation MyClass
@synthesize myProp = _myProp; // or just leave it at the default name..
@end

实例变量的可见性是_myProp多少？也就是说,这是考虑过@public,@protected还是@private？我猜是因为MySubClass可以从那时继承MyClass它也会得到属性(自然),但是它还会继承实例变量可见性吗？

如果我将属性放在类扩展中会有什么不同？这会将属性隐藏在子类中,我也猜测实例变量.这记录在哪里？

我正在学习C#,并且正在学习如何将字段设为私有类,并使用Getters和Setters来公开方法而不是字段值.

是get; set;在方法1和方法2相同呢？例如,一个是另一个的速记吗？

class Student
{
    // Instance fields
    private string name;
    private int mark;

    // Method 1
    public string Name { get; set; }

    // Method 2
    public int Mark
    {
        get { return mark; }
        set { mark = value; }
    }
}

最后,如果您想在获取或设置值之前执行计算,是否可以使用方法2？例如,将值转换为百分比或执行验证？例如

class Student
{
    // Instance fields
    private string name;
    private double mark;
    private int maxMark = 50;

    // Method 1
    public string Name { get; set; …

假设我有一个private ArrayList或一个LinkedList类,我永远不会为它分配新的引用,换句话说,这将永远不会发生:

myLinkedList = anotherLinkedList;

所以我不需要使用setMyLinkedList(anotherLinkedList).

但!我需要添加元素,或从中删除元素.

• 我应该写一种新的setter只,做的任务adding,而不是setting像myLinkedList.add(someElement)？

• 或者可以通过使用getter而不违反Encapsulation委托人来做到这一点？

  getMyLinkedList().add(someElement)

(+假设如果我不服从封装,我将失去我的标记: - ")

我刚刚发现Me关键字即使在它们自己的类模型中也无法访问私有过程.

在Class1中使用以下代码:

Private Sub Message()
    Debug.Print "Some private procedure."
End Sub

Public Sub DoSomething()
    Me.Message
End Sub

此代码实例化该类的实例:

Sub TestClass()
    Dim objClass As New Class1
    objClass.DoSomething
End Sub

Me.Message 抛出编译错误"找不到方法或数据成员".

如果我改变Private Sub Message()到Public的程序工作正常.我也可以从DoSomething过程中删除Me关键字,但我的印象是Me关键字背后的想法是确保Class1的多个实例被正确封装.

为什么VBA Me关键字在私有时无法在自己的模块中访问？省略Me关键字并在类中执行类似的操作是否安全？

Private Sub Message()
    Debug.Print "Some private procedure."
End Sub

Public Sub DoSomething()
    Message
End Sub

谢谢!

更新:感谢有关正确语法的提示,我的代码正常运行.我仍然在寻找一个解释,为什么我可以在它自己的模块的实例中引用私有过程.我找不到任何好的文件.

response_to可能不是那么明显吗？在红宝石中工作.考虑一下:

class A

   def public_method
   end

   protected
   def protected_method
   end

   private
   def private_method
   end

end

obj = A.new
obj.respond_to?(:public_method)
# true - that's pretty obvious
obj.respond_to?(:private_method)
# false - as expected
obj.respond_to?(:protected_method)
# true - WTF?

因此,如果'obj'响应protected_method,我们应该期待

obj.protected_method

我不应该提出异常吗？

......但它明显提升了

调用respond_to的文档点？第二个参数设置为true也检查私有方法

obj.respond_to?(:private_method, true)
# true

这更合理

所以问题是如何检查对象是否只响应公共方法？有没有比这更好的解决方案？

obj.methods.include?(:public_method)
# true
obj.methods.include?(:protected_method)
# false

edit4:wikified ,因为这似乎已经变成了讨论而不是特定的问题.

在C++编程中,通常认为"更喜欢非成员非朋友函数"而不是实例方法是一种好习惯.这是Scott Meyers在这篇经典的Dr. Dobbs文章中推荐的,Herb Sutter和Andrei Alexandrescu在C++编码标准中重复了这一点(第44项); 一般的论点是,如果一个函数只能通过依赖类暴露的公共接口来完成它的工作,它实际上增加了封装,使其成为外部的.虽然这在某种程度上混淆了班级的"包装",但通常认为其好处是值得的.

现在,自从我开始用C#编程以来,我有一种感觉,这就是他们试图通过"非成员,非朋友的函数来实现这个概念的最终表达"接口".C#为混合添加了两个关键组件 - 第一个是接口,第二个是扩展方法:

• 接口允许一个类正式指定他们的公共合同,他们暴露给世界的方法和属性.
• 任何其他类都可以选择实现相同的接口并实现相同的合同.
• 可以在接口上定义扩展方法,提供可以通过接口自动实现到所有实现者的任何功能.
• 最重要的是,由于"实例语法"糖和IDE支持,它们可以像任何其他实例方法一样被调用,从而消除了认知开销!

因此,您可以通过会员的便利获得"非会员,非朋友"功能的封装优势.对我来说似乎是两全其美的事情; .NET库本身在LINQ中提供了一个光辉的例子.然而,我看到的每个地方都看到人们警告不要过度使用扩展方法; 甚至MSDN页面本身都说明:

通常,我们建议您谨慎实施扩展方法,并且只在必要时才实施.

(编辑:即使在目前的.NET库,我能看到它会一直有扩展,而不是实例方法有用的地方-例如,所有的实用功能List<T>(Sort,BinarySearch,FindIndex等)将是非常有用的如果他们被提升到IList<T>- 获得这样的免费奖励功能可以为实现界面带来更多好处.)

那么判决是什么？扩展方法是封装和代码重用的极致,还是我只是在欺骗自己？

(编辑2 :对Tomas的回应 - 虽然C#确实从Java(过度,imo)OO心态开始,但似乎每个新版本都采用了更多的多范式编程;这个问题的主旨是使用扩展方法来推动风格改变(朝向更通用/功能性的C#)是有用或有价值的.)

edit3:可覆盖的扩展方法

到目前为止,使用此方法确定的唯一真正问题是,如果需要,您无法专门使用扩展方法.我一直在考虑这个问题,我想我已经找到了解决方案.
假设我有一个接口MyInterface,我想扩展 -

我在MyExtension静态类中定义我的扩展方法,并将其与另一个接口配对,调用它MyExtensionOverrider.MyExtension方法是根据这种模式定义的:

public static int MyMethod(this MyInterface obj, …

我有class A如下所述: -

class A{
     int iData;
};

我既不想创建成员函数也不继承上面的内容,class A也不想更改说明符iData.

我的疑惑: -

• 如何访问iData一个对象说obj1哪个是实例class A？
• 如何更改或操纵iData对象obj1？

注意:请勿使用friend.

我正在Clojure中开发一个具有多个子结构的复杂数据结构.

我知道我会想要随着时间推移扩展这个结构,有时可能想要改变内部结构而不会破坏数据结构的不同用户(例如我可能想要将一个向量更改为一个hashmap,添加某种索引出于性能原因的结构,或者包含Java类型)

我目前的想法是:

• 使用各种访问器方法为整体结构定义协议
• 创建一个导航数据结构的迷你函数库,例如(query-substructure-abc param1 param2)
• 使用defrecord或deftype实现数据结构,并使用定义的协议方法来使用迷你库

我认为这会有效,但我担心它开始看起来像很多"胶水"代码.它也可能反映了我对面向对象方法的更多熟悉.

在Clojure中推荐的方法是什么？