标签: protected

我想要类似的东西protected,其中只有一个实现该protected字段的类和它的子类可以访问它.

所以,我希望能够在基类中声明一个变量private,但仍然能够从子类中访问它.

也许这违背了子类化的本质private,和/或protected.

Java中是否存在类似的内容？

给定一个抽象接口和从该接口派生的实现,其中构造函数受到保护(这些对象的创建只能从类工厂中获得 - 实现DI模式),如何在工厂函数中使用make_shared？

例如:

class IInterface
{    
public:    
    virtual void Method() = 0;
};

class InterfaceImpl : public IInterface
{
public:
    virtual void Method() {}

protected:    
    InterfaceImpl() {}    
};

std::shared_ptr<IInterface> Create()
{
    std::shared_ptr<IInterface> object = std:: make_shared<InterfaceImpl>();    
    return object;
}

make_shared显然无法访问InterfaceImpl中的受保护构造函数,或者实际上是在IInterface中,给出了以下错误

error C2248: 'InterfaceImpl::InterfaceImpl' : cannot access protected member declared in class 'InterfaceImpl'

所以在这里阅读(问题:如何使boost :: make_shared成为我班级的朋友),我尝试将以下内容放入实现类中:

friend std::shared_ptr<InterfaceImpl> std::make_shared<InterfaceImpl>();

它仍然无法编译.那么我也将另一个放入IInterface类.仍然没有快乐.我在这做错了什么？

编辑:用于编译的完整源文件,与"朋友"...

#include <memory>

class IInterface
{    
public:    
    friend std::shared_ptr&lt;IInterface> Create();     
    virtual void Method() = 0;
};

class …

如何保护我的变量免受此类攻击:

MyClass.__dict__ = {}
MyClass.__dict__.__setitem__('_MyClass__protectedVariable','...but it is not')

上面改变了变量字典,之后是孩子们玩改变所有变量.上线对于此工作至关重要.如果您的字典__setitem__被调整如下,则上述方法无效.

我想强制用户使用我的方法setProtectedVariable(value)来更改变量,但我似乎没有办法在Python 2.7中这样做.有任何想法吗？

如果您从下面的代码中找到其他类似的漏洞,我也很感激(我注意到我还应该在我的inspect.stack办理登机手续中添加文件名和行号myDict.__setitem__).

这是我到目前为止所尝试的:

import inspect

class ProtectionTest:

    __myPrivate = 0

    def __init__(self):
        md = myDict()
        setattr(self,'__dict__', md)

    def __setattr__(self, name, val):     
        if name == '__myPrivate':
            print "failed setattr attempt: __myPrivate"
            pass
        elif name == '_ProtectionTest__myPrivate':
            print "failed setattr attempt: _ProtectionTest__myPrivate"  
            pass
        elif name == '__dict__':
            print "failed setattr attempt: __dict__"
            pass
        else: 
            self.__dict__[name] = val             

    def getMyPrivate(self):
        return self.__myPrivate

    def setMyPrivate(self, myPrivate): …

我在Crystal Report Viewer的打印按钮上收到错误"尝试读取或写入受保护的内存..".此错误是随机的,有时报告打印时没有任何错误.有时它会给出错误,因为"句柄无效".我已尝试在互联网上提供2-3个解决方案,例如取消选中"抑制JIT优化.."选项,但没有任何对我有用.请帮忙!!(其他详细信息:Crystal Reports 2011,Crystal Reports for VS2010版本13.0.2,C#2010 winforms应用程序)

我想在JAVA中创建一个受密码保护的文件。我的意思是，一旦启动程序，由程序创建的一个文件将直接受到先前确定的密码的保护。

有简单的方法吗？

再一次，我的目的不是创建文件然后添加密码，而是在创建过程中通过密码保护文件。 实际上，我希望当前的运行程序没有访问权限，除非他/她具有先前设置的密码，否则无法读取/编辑创建的文件。

因此，无论如何，如果您中的某些人由于使用Java而在编写文件时知道一种保护文件的简便方法，我将不胜感激。

祝你今天愉快！

在阅读"Hello,Android"一书时,我注意到:

每个带有onCreate(Bundle savedInstanceState)方法的java文件,在程序的主Activity中都有 受保护的访问修饰符EXCEPT [具有:public void onCreate(Bundle savedInstanceState)].

为什么程序的主要Activity上的onCreate方法public,但protected在其他地方？

此问题是FilterInputStream / FilterOutputStream的空源的以下问题

这个问题可能与受保护vs公共构造函数的抽象类重复吗？有区别吗？（C＃）

我发现FilterInputStream是这样设计的。

public class FilterInputStream extends InputStream { // concrete

    protected FilterInputStream(InputStream in) { // protected
        // ...
    }
}

我的问题是，如果代码是

public abstract class FilterInputStream extends InputStream { // abstract

    public FilterInputStream(InputStream in) { // public
        // ...
    }
}

是否可以从任何孩子访问protected变量？或者只能通过特定的访问？我的情景清楚地表达了我的怀疑.parentObjectObjectchildObject

我有两个类ParentClass和ChildClass.ParentClass是...的父母ChildClass.我有一个名字protected变量.它是类型.然后,我创建两个像下面这样的.ParentClassprotVarObjectObject

ParentClass p1 = new ParentClass();
ChildClass c1 = new ChildClass();
c1.callMethod(p1); // Here I want to access protected variable of p1 which is a separate object and Not initialized within c1 as super()

现在,我将能够访问protVar的p1从c1？

我正在尝试从模板中公开派生一个类,这个类将使它从基类继承并获得受保护成员的访问权限.但是在扩展模板之前它没有这些权限,因此它不能使用Base成员作为模板参数:

using Fun = void (*)();

class Base {
protected:
    // friend class Derived; // ...need this to eliminate complaint
    static void something();
};

template<Fun F>
class Variant : public Base {};

class Derived : public Variant<&Base::something> { // `something()` is protected
public:
    void somethingElse() {
        something(); // doesn't complain about this `something()`
    }
};

int main() {}

关于这一点的奇怪之处在于,它的功能完全正常.我想知道我是否可以通过在Variant之前放置一个来自Base的公共虚拟继承来"偷偷入门":

class Derived : public virtual Base, public Variant<&Base::something>

这没有用.

问题:是否有其他一些技巧可以避免在Base中明确提及所有派生类,但是仍然可以从模板参数中选择受保护的成员吗？

(注意:在较旧的gcc,4.6.3上尝试这个,看起来甚至连朋友在这种情况下也无济于事.所以看起来对它的支持有点新.)

这是代码:

class TestA
{
protected:
    int test=12;

public:
    TestA() {
        cout << "test a: " << test << endl;
    }
    ~TestA() {
    }
};

class TestB : public TestA
{   
public:
    TestB(TestA *testA) {
        cout << "test b: " << testA->test;
    }
    ~TestB() {
    }
};

int main ()
{
    TestA *pTestA=new TestA();
    TestB *pTestB=new TestB(pTestA);
}

我正在尝试protected使用指向TestA类型对象的指针(因此,实例TestA)来访问成员.TestB也来源于TestA

为什么我无法访问它？它只能在我需要它的类中"访问"吗？不在外面使用指针/直接声明？