难道这两类破坏封装?

class X { protected: void protectedFunction() { cout << "I am protected" ; } }; class Y : public X { public: using X::protectedFunction; }; int main() { Y y1; y1.protectedFunction(); }

这样一来,我能够暴露的基类的功能之一。

  1. 这是否违反了封装原则?
  2. 是否有一个具体的理由,为什么这是标准?
  3. 是否有这样的任何用途,或者它会在新标准改变?
  4. 有没有标准中与此相关的任何未解决的问题?

--------------解决方案-------------

是它,这就是为什么保护已经收到批评的公平份额。

Bjarne的Stroustrup的,C ++的创造者,对此表示遗憾在他的优秀著作的设计和C ++的演变:

我的一个关于保护的担忧,正是它使得它很容易使用共同的基地之一可能拖泥带水已经使用全局数据的方法....现在回想起来,我认为这是受保护的情况下“好争论”与时尚克服了我的判断,我的经验法则接受新功能。

你自己做的。
你可以写

class Y : public X
{
public:
void doA()
{
protectedFunction();
}
};

int main()
{
Y y1;
y1.doA();
}

我看不出有任何理由要担心。
受保护的功能是可重复使用的逻辑在继承树件。 你可以隐藏它们是否有某种内在的逻辑或限制或像你的情况可以公开它,如果你确信这不会伤害任何人。

我认为这是斯特劳斯本人认为封装和数据完整性功能内置到C ++的目的是保持诚实的人诚实,不停止犯罪。

号protectedFunction()被保护。 你可以自由地从派生类调用它,所以你可能会直接从y的公共成员的话来说,叫主从这个公共成员()。

如果你能这样做,是一个私有方法 ,也将是一个问题......(编辑以便更清楚一点)。

从语言角度,这不是更违反封装比创建的派生类对象的委托方法的:

class Y : public X
{
public:
void protectedFunction() {
X::protectedFunction();
}
};

一旦一个方法是受保护的,它提供给派生类与它为所欲为。 其目的为using声明没有改变继承的方法访问,而是回避问题的方法hidding(其中在一个公共的方法X将隐藏在类型Y如果一个不同的过载定义)。

现在,这是一个事实,由于语言的规则,它可以用来改变“拿来主义”的方法为你的榜样的访问级别,但并没有真正打开系统中的任何漏洞。 最后,派生类不能做任何事情超过他们可以做什么之前。

如果实际的问题是,特定的使用是否是从设计的角度来看(其中设计这里是应用程序的设计,而不是语言设计)违反封装,那么最有可能是肯定的。 在正是使得内部数据或方法公开的方法相同。 如果它的目的是通过最初的设计者保护X然后有机会Y实现者不希望它是公共...(或为同一目的提供委托法)

没有。

要使用公共的方法,你应该有一个实例Y这是不行的:

int main()
{
X y1;
y1.protectedFunction();
}

如果Y在其新定义暴露了一个新的接口,它是由该Y的X被仍然受到保护。

类设计师应该知道,声明一个成员函数或变量(尽管所有的变量应该是私有的,真的)的保护主要是一样的宣布它的公共(为你显示它很容易获得访问受保护的东西)。 考虑到这一点,小心为实现这些功能时,在基类中占“意外”的使用采取。 这是不是违反封装的,因为你可以访问它,揭露它。

受保护的仅仅是一个更复杂的东西,宣布公开方式!

在C ++中甚至私人修饰符不保证密封。 没有人能搬起石头砸自己的脚阻止你。

香草萨特在他的文章“的访问权限使用和滥用”不同的演示功能的方式如何“破坏封装”。

在这里,从香草的文章有趣的例子。

邪恶的宏观魔术

#define protected public // illegal
#include "Xh"
//...
X y1;
y1.protectedFunction();

不,我实在不明白的问题。

相反的using ,你可以这样做:

class X
{
protected:
void protectedFunction() { cout << "i am protected" ; }
};

class Y : public X
{
public:
void protectedFunction() { X::protectedFunction(); }
};

任何类可以采取的是可见的任何成员,并决定公开揭露它。 它可能是坏一流的设计做到这一点,但肯定不是在语言中的缺陷。 在私人或受保护的成员,整个的一点是,类本身必须决定谁应该获得访问该成员。 如果该类决定“我要去给整个世界访问”,那么这是怎么类的设计。

如果我们通过按照你的逻辑,那么getter和setter方法​​破坏封装太多。 有时他们做的。 但是,并非因为语言被打破。 很简单,因为你选择的设计碎类。

通过使成员的保护,你给派生类的自由做点儿自己喜欢的成员。 他们能看到它,这样他们就可以修改它,或公开暴露。 你选择了实现这一点,当你做保护的成员。 如果你不想这样,你应该做了它私有的。

我个人认为这个问题要回答,更多的是设计的问题,而不是技术问题。

我会问,“什么是摆在首位的保护方法的呢?” 是不是只有子类应调用,或者是它的子类应该重写的方法的方法? 然而,它可以是不期望在一个通用的基类,但也许预期在子类中的方法。 基类的客户,他们从来不知道有关保护的方法。 子类的创建者选择了扩大的合同,现在受保护的方法是公开的。 真正的问题应该是不确实c + +允许它,但它是适合你的班级,重合同,将来的维护。 当然这可能是一个不好的气味,但真的是你需要做出正确所涉及的用例。

如果使受保护的方法公开,那么要确保正确的维护者解释为什么这个决定作出的理由提供的内部文件。

虽然在一般,为安全起见提到以前的参与者,则可能需要使用一个委托函数(使用不同的名称)的子类。 因此,而不是“GET(INT)”你可能有“getAtIndex(INT)”什么的。 这使您可以更轻松地重构/保护/抽象/文档,在未来的。

分类:C# 时间:2013-01-11 人气:0
本文关键词: C#中,继承,封装
分享到:

相关文章

Copyright (C) 55228885.com, All Rights Reserved.

55228885 版权所有 京ICP备15002868号

processed in 0.769 (s). 10 q(s)