据我所知,C++中只有3个访问说明符:私有,公共,受保护
与这些3访问说明符,我怎样才能使一个方法可用到的类中的项目,但不能使用于"外国人" ??(如内部和公共在C#)
我知道C++ 之间struct和classC++ 之间的差异很小.我也理解几个差异的原因.像这个,
C++-struct兼容C-struct.并且默认情况下,类成员是私有的原因是引入数据封装的概念(即强制执行面向对象的原则/技术/等).我不明白的是,引用标准$ 11.2/2 [class.access.base]
如果没有基类的访问说明符,则在派生类声明为struct时假定为public,并在声明类时声明为private.
这种扭曲和反均匀性的基本原理是什么？为什么需要这种差异？
标准示例,
class B { };
class D1 : private B { };
class D2 : public B { };
class D3 : B { }; //B private by default
struct D4 : public B { };
struct D5 : private B { };
struct D6 : …目前正在编写一个类,其中我正在考虑私有的方法遍布整个代码.private我想在类的顶部做一个内联声明,而不是添加一行并复制粘贴它下面的所有内容private :foo, :bar.
但是,每当我尝试将参数声明为私有内联的方法时,我都会收到一条错误消息.举例来说,如果我有一个方法foo(bar, baz),并尝试声明它与私人private :foo(bar, baz)我得到的两个括号错误信息,希望kEND和=替代.
如果我尝试声明它private :foo,我会被告知foo在我的代码中没有这样的方法.
如何在不发生这些错误的情况下做我想做的事情？
可能重复:
公共虚拟函数在C++中派生为private
class B
{
private:
int b;
public:
B(int i);
virtual void show()
{
cout<<"B::show()called. "<<b<<endl;
}
};
B::B(int i=0)
{
b=i;
}
class D:public B
{
private:
int d;
void show()
{
cout<<"D::show() called. "<<d<<endl;
}
public:
D(int i, int j);
};
D::D(int i=0, int j=0):B(i)
{
d=j;
}
void fun(B&obj)
{
obj.show();
}
/*if I redefine fun() as follow, the result would be the same
void fun(B*obj)
{
obj->show();
}
*/
int main()
{
D *pd=new D(5,8); …C#中Main方法的默认访问说明符是什么？
如果static void Main()的默认访问说明符是私有的,那么外部实体如何例如.OS调用这个方法？
任何外来进程都不应该调用此方法.
如果您没有定义访问权限,C++中的成员变量会发生什么？
例如,在以下代码中:
class Base {
int myQuestion;
public:
int myPublic;
private:
int myPrivate;
}
谁有权访问myQuestion？
interface Rideable {
String getGait();
}
public class Camel implements Rideable {
int weight = 2;
String getGait() {
return " mph, lope";
}
void go(int speed) {++speed;
weight++;
int walkrate = speed * weight;
System.out.print(walkrate + getGait());
}
public static void main(String[] args) {
new Camel().go(8);
}
}
编译上面的代码后,我得到了一个编译错误,与getGait()方法的访问修饰符有关.请解释一下,为什么我要getGait()使用public访问修饰符声明？
所以我有一个变量,我经常要在课外打电话,有人告诉我应该这样做:
class Foo{
public:
//stuff
Type getVariable();
private:
Type Variable;
//stuff
}
但为什么我不能只使用:
class Foo{
public:
//stuff
const Type variable
private:
//stuff
}
在使用包访问级别抽象类的非静态方法公开vs使它们受到保护时是否存在任何安全/访问差异？只有扩展抽象类的同一个包中的类才能访问非静态方法吗？那么,这些非静态方法是公共的还是受保护的是否重要,因为抽象类本身会限制谁可以扩展它？
abstract class MyClass {
protected void myFunction(){
System.out.println("Only child classes can print this");
}
}
abstract class MyClass {
public void myFunction(){
System.out.println("Still, only child classes can print this");
}
}
如果方法受保护，则定义类或其子类的任何实例都可以调用该方法。如果方法是私有的，则只能在调用对象的上下文中调用它-即使对象与调用者属于同一类，也永远无法直接访问另一个对象的私有方法。
当在ruby中搜索私有方法和受保护方法之间的区别时，我从网上得到了这个定义。
我对此有2个疑问
class Abc
def abc
xyz
end
protected
def xyz
p "hai"
end
end
a=Abc.new
a.abc
在这种情况下，我隐式地在对象a上调用xyz，即使我是私有的，这也是我将如何调用xyz。所以“定义类的任何实例都可以调用它”是什么意思？
其次，
class Abc
def abc(obj)
obj.xyz1
obj.xyz2
obj.xyz3
end
end
class Xyz
def xyz1
p "called"
end
private
def xyz2
p "called"
end
protected
def xyz3
p "called"
end
end
a=Abc.new
b=Xyz.new
a.abc(b)
在这种情况下，我可以在对象a上调用obj b的xyz1方法。但是我不能在对象a上调用obj b的受保护xyz3方法和私有方法xyz2方法。因此“即使对象属于与呼叫者同班。” 这确切是什么意思？？？
有人可以通过更好的例子帮助我理解这一点吗？