标签: protected

这个问题类似于c#内部抽象类,如何隐藏外部使用但我的动机不同.这是场景

我从以下开始:

internal class InternalTypeA {...}

public class PublicClass
{
   private readonly InternalTypeA _fieldA;

   ...
}

上面的编译很好.但后来我决定提取一个基类并尝试编写以下内容:

public abstract class PublicBaseClass
{
   protected readonly InternalTypeA _fieldA;

   ...
}

因此问题是,受保护的成员在程序集外部是可见的,但是是内部类型,因此它不会编译.

手头的问题是如何(或者我可以？)告诉编译器只有与PublicBaseClass相同的程序集中的公共类可以继承它,因此_fieldA不会在程序集之外公开？

或者是否有另一种方法可以做我想做的事情,有一个公共超类和一组公共基类,它们都在同一个程序集中,并使用它们的公共("受保护")代码中的该程序集的内部类型？

到目前为止我唯一的想法是:

public abstract class PublicBaseClass
{
   private readonly InternalTypeA _fieldA;

   protected object FieldA { get { return _fieldA; } }

   ...
}

public class SubClass1 : PublicBaseClass
{
    private InternalTypeA _fieldA { get { return (InternalTypeA)FieldA; } } 
}

public class SubClass2 : PublicBaseClass
{
    private InternalTypeA …

我试图反映一种类型，并只获取具有公共设置器的属性。这似乎不适用于我。在下面的示例LinqPad脚本中，“ Id”和“ InternalId”与“ Hello”一起返回。我该怎么做才能将它们过滤掉？

void Main()
{
    typeof(X).GetProperties(BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.Instance)
    .Select (x => x.Name).Dump();
}

public class X
{
    public virtual int Id { get; protected set;}
    public virtual int InternalId { get; protected internal set;}
    public virtual string Hello { get; set;}
}

我将我的 C++ 基类更改为protected继承，并且我的dynamic_cast(s) 停止工作。

为什么要改变继承来protected改变行为dynamic_cast？

struct Base {
  static Base *lookupDerived(); // Actually returns a Derived * object.
};

struct Derived : protected /* Switch this to public to get it working */ Base {
 static void test() {
   Base *base = lookupDerived();

   if (dynamic_cast<Derived *>(base)) {
      std::cout << "It worked (we must be using public inheritance)." << std::endl;
   } else {
      std::cout << "It failed (we must be using protected inheritance)." …

我正在寻找一种在 Windows 平台上创建共享内存块的可能性，该共享内存块对除创建共享内存块的进程之外的所有进程都进行写保护。

详细来说，我需要以下内容：

进程（1）必须创建一个共享内存块并且应该能够修改缓冲区。进程（2）应该能够打开并读取创建的共享内存块，但不得具有修改内容的权限。出于安全原因，这一点很重要。

目前，我有一个使用 CreateFileMapping() 和 MapViewOfFile() 创建共享内存块的解决方案，然后该解决方案在进程 (1) 和 (2) 中具有读写权限，如下所示：

HANDLE handle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, highSize, lowSize, L"uniquename");
void* sharedMemory = MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, 0);
// now we can modify sharedMemory...

这两行代码可以应用于两个进程，因为第一个进程创建共享内存块，第二个进程只是打开共享内存。但是，显然，由于在创建内存块期间提供的访问值（PAGE_READWRITE 和 FILE_MAP_ALL_ACCESS），第二个进程将具有写入权限。

我需要通过使用访问值 PAGE_READONLY 和 FILE_MAP_READ 在进程（1）中创建共享内存块，但显然我不允许初始化/设置/修改进程（1）中的内存块，这是一个无用的内存缓冲区。

据我所知，安全属性的定义无法解决问题，因为我的问题不依赖于用户或组。

我什至对这样的解决方案感到满意，该解决方案在进程（1）中创建共享内存块，依赖于创建共享内存块之前已知的内存内容（并且之后不会在进程（1）中修改）。

我正在尝试在 Lucene 信息检索 api 中使用受保护的静态方法。我对 static 的理解是，它们是从类定义中访问的，而我对 protected 关键字的理解是，它们只能从该类或子类的实例中访问。那么到底如何访问静态受保护方法呢？难道我的理解有误？我试图从导入的 jar 中的库调用受保护的静态方法。我该怎么做呢？

在本例中，我从StopwordAnalyzerBase调用 loadStopwordSet

我正在尝试一个小例子来练习继承和多态性的概念。这是我的代码的简化版本：

class Shape {
protected:
    int length;
    int width;
public:
    virtual void setLength(int l) = 0;
    virtual void setWidth(int w) = 0;
};

class Rectangle : public Shape {
public:
    Rectangle(int l, int w)
    : length(l), width(w)
    { }

    void setWidth(int w) { width = w; }
    void setLength(int l) { length = l; }
};

int main() {
    Rectangle r(0,0);
}

我正在尝试运行上面的程序。但是，当我编译矩形.cc 时，出现以下错误

g++ -c rectangle.cc

rectangle.cc: In constructor 'Rectangle::Rectangle(int, int)':
rectangle.cc:13:5: error: class 'Rectangle' does not have any …

这个问题来自于使用方法链接时出现的问题(流畅的界面),我认为这是它可能成为问题的唯一原因之一.

为了说明,我将使用方法链接的示例:

在单元A中:

TParent = class
protected
  function DoSomething: TParent;
end;

在单元B中:

TChild = class(TParent)
public
  procedure DoAnotherThing;
end;

implementation

procedure TChild.DoAnotherThing;
begin
  DoSomething.DoSomething
end;

我想保持DoSomething过程受保护,只对类后代可见.

这不会编译,抛出一个

无法访问受保护的符号TParent.DoSomething

因为DoSomething返回一个TParent,后续的DoSomething调用是从另一个单元中的TParent对象发出的(因此保护启动并且函数无法访问).(谢谢David Heffernan的解释)

为了减少它的本质,像TParent(Self).DoSomething在TChild类中是不可能的.

我的问题:

既然编译器确实知道从子类中访问Self参数的副本,那么是否存在访问祖先的受保护方法的能力破坏封装的实例？我只是谈论从后代的类方法中取消引用类型化的Self .我知道在这个类之外,该参数当然不应该访问祖先的受保护方法(在另一个单元中).

同样,简而言之:当一个与Self参数相同的变量在其自身的一个类方法中被取消引用时,编译器是否允许它访问其父级的受保护方法是不安全的(就像Self参数本身一样) )？

这是一个非常理论上的问题,但如果编译器允许这样做,我会对编译代码或封装会产生任何负面影响感兴趣.

谢谢.

假设基类A定义了一个受保护的成员。派生类B使用此成员。

class A
{
public:
  A(int v) : value(v) { }

protected:
  int value;
};

class B : public A
{
public:
  B(int v) : A(v) { }
  void print() const;
  void compare_and_print(const A& other) const;
};

该函数B::print只获取当前成员的值并打印它：

void B::print() const
{
  std::cout << "Value: " << value << "\n";
}

另一个成员函数 ，B::compare_and_print采用 的实例A，检查它们的值并打印两者的最大值：

void B::compare_and_print(const A& other) const
{
  auto max_value = std::max(value, other.value);
  std::cout << "Max value: " …

在查看java代码时，我发现抽象类的构造函数被设置为受保护的。

public abstract class A {
   protected A() {

   }
}

什么

抽象对我来说意味着你不能创建此类的实例并在扩展后使用此类

。

受保护的构造函数也确保了这一点。

做两件事有什么意义，一是使构造函数受保护，二是使类抽象以解决相同的目的。

我想创建一个受密码保护的 ZIP 文件。

以前有人这样做过吗？你能给我一些建议吗？我在 pub.dev 上找不到合理的包。