我有一个基类,比如BassClass,有一些字段,我让它们受到保护,还有一些纯虚函数.然后派生类,比如说DerivedClass像class DerivedClass : public BassClass.DerivedClass不应该从BassClass继承受保护的字段吗？当我尝试编译DerivedClass时,编译器抱怨DerivedClass没有任何这些字段,这里有什么问题？谢谢
给出示例代码:
class Base {
public:
bool pub;
protected:
bool prot;
};
class Derived : private Base {
friend class MyFriend;
};
class MyFriend {
Derived _derived;
void test() {
// Does standard provide me access to _derived.pub and _derived.prot?
cout << "Am I allowed access to this: " << _derived.pub
<< " and this: " << _derived.prot;
}
};
做朋友会给我所有的访问权限,我会得到好像我是班级中的一员,我是他的朋友吗？换句话说,由于我是朋友,我可以获得私人继承的基类的受保护和公共成员吗？
所以我正在尝试解决我在设计PHP类时遇到的问题.我已经创建了一个基类,并分配了私有变量.我有扩展这个基类的子类,它通过基类的函数对这些私有变量进行引用和更改.下面是一个例子,记住我仍然感到困惑之间的区别private和protected方法/变量(让我知道如果我做错了!):
base.class.php
<?php
class Base {
private $test;
public function __construct(){
require('sub.class.php');
$sub = new Sub;
echo($this->getTest());
}
public function getTest(){
return $this->test;
}
protected function setTest($value){
$this->test = $value;
}
}
?>
sub.class.php
<?php
class Sub extends Base {
public function __construct(){
parent::setTest('hello!');
}
}
?>
所以我希望将结果hello!打印在屏幕上 - 而不是什么都没有.我可能会对课程产生根本性的误解,或者我可能只是做错了什么.非常感谢任何指导!谢谢.
编辑:
感谢所有提供答案的人 - 我认为,尽管有很好的解决方案,但是这些子类实际上并不是我需要的 - 似乎委托类在这一点上可能更有用,因为我真的不需要引用Base其他类中的函数.
我在包中有一个抽象类foo(在这个特殊情况下,一个特性),可以由各种子类实现,我想创建一个正交子类,用于一个更具体的包bar,添加特定于包的信息.似乎最好的方法是通过组合(包装)而不是继承,因为否则我必须声明每个foo-package子类的特定于包的版本.但这会导致需要转发的受保护成员出现问题:
package foo {
trait Foo {
protected def bar: Int
}
}
package bar {
import foo.Foo
class Baz
class WrapFoo(wrapped: Foo) extends Baz with Foo {
protected def bar = wrapped.bar
}
}
这会导致错误:
~/test/scala 14:54 152272% scalac testprotected.scala
testprotected.scala:11: error: method bar in trait Foo cannot be accessed in foo.Foo
Access to protected method bar not permitted because
prefix type foo.Foo does not conform to
class WrapFoo in package bar where …我在Java中有以下代码
public class First {
protected int z;
First()
{
System.out.append("First const");
}
}
class Second extends First {
private int b;
protected int a;
}
class Test {
/**
* @param args the command line arguments
*/
int a=0;
public static void main(String[] args) {
// TODO code application logic here
First t=new Second();
t.z=10; work fine
First x=new First();
x.z=1; // works fine
}
}
所以我可以z通过创建base类的对象来访问
C#
class A
{
protected int x = …我有一个类和另一个继承自它的类。我在父类中定义了一些方法，我想与子类私下共享，但不与世界共享。
对于此类方法，如何在其他编程语言中实现类似受保护范围的功能？
我已经考虑过引入一个具有私有方法的角色，但我还需要维护一些私有状态以供方法使用，并且我需要使两个类都does成为角色，但这似乎导致了实例变量（角色）在两个班级中都重复...
在Python中，类中的受保护变量和公共变量有什么区别
class A:
def __init__(self):
self._protected="protected"
self.__private="private"
self.public="public"
>>> a = A()
>>> a.public
'public'
>>> a._protected
'protected'
>>>
有人可以解释一下其中的区别，并指导我如何在 python 中使用受保护的变量吗[如果我的方法用法是错误的]
提前致谢。
这个问题类似于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 …我想知道在Fortran中是否有一种全局变量的方法,可以说是某种"受保护".我在想一个包含变量列表的模块A. 使用A的每个其他模块或子例程都可以使用它的变量.如果你知道变量的值是什么,你可以使用参数来实现它不能被覆盖.但是如果你必须先运行代码来确定变量值呢？您无法将其声明为参数,因为您需要更改它.有没有办法在运行时的某个特定点做类似的事情？
尝试在公共类中创建受保护的内部类的受保护内部成员会导致以下问题:
可访问性不一致:字段类型'what.Class1.ProtectedInternalClass'比字段'what.Class1.SomeDataProvider.data'更难访问
据我所知,可访问性应该是等效的.
我哪里弄错了？
起源类:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace what
{
public class Class1
{
// This class cannot be modified, is only
// here to produce a complete example.
public class PublicClass
{
public PublicClass() { }
}
protected internal class ProtectedInternalClass : PublicClass
{
public ProtectedInternalClass() { }
public void SomeExtraFunction() { }
}
public class SomeDataProvider
{
public int AnInterestingValue;
public int AnotherInterestingValue;
protected internal ProtectedInternalClass data; //<--- Occurs here.
public PublicClass …