访问说明符以及类和对象？

Question

好吧，我试图理解这一点，

所以类只是为对象创建模板。

class Bow
{

int arrows;

};

对象只是使用类模板创建特定项。

Bow::Bow(arrows)
{
arrows = 20;
}

还有另一个问题，公共说明符用于使对象中的数据成员可用，而私有说明符用于使类中的数据成员仅可用？

Answer 1

您给出的描述大部分是正确的，但是您的示例并未显示您的描述。

一个类描述了一组数据成员和可以在这些数据成员上调用的成员函数：

class Bow
{
public:
   //Constructor
   Bow::Bow()
   {
     arrows = 20;
   }

   Bow::Bow(int a)
   {
     arrows = a;
   }


   //member functions (in this case also called accessors/modifiers)
   void getArrows(int a) const
   {
     return arrows;
   }

   void setArrows(int a)
   {
     arrows = a;
   }

protected:
  int arrows;
  };

类的对象只是该类的一个实例。

//b and d are objects of the class Bow.
Bow b(3);//The constructor is automatically called here passing in 3
Bow d(4);//The constructor is automatically called here passing in 4
Bow e;//The constructor with no parameters is called and hence arrows = 20

注意：我故意避免使用您使用的单词模板，因为它在C ++中的使用与您的意思完全不同。

---

要了解公共/私有/受保护的说明符：

public：表示该类的对象可以直接使用成员。

protected：表示该类的对象不能直接使用成员。 基于该类的派生类可以使用成员。

private：表示该类的对象不能直接使用成员。 基于该类的派生类也不能使用成员。

所以在上面的例子中：

Bow b(3);
b.arrows = 10;//Compiling error arrows is not public so can't be accessed from an object

Answer 2

公开表示该成员对班级外部的代码可见。 私有意味着该成员仅对类内部的代码可见（或类指定的任何内容为其朋友）。

例如：

class X { 
    int priv;
public:
    int pub;

    do_something() { 
        // since do_something() is part of X, it can change both pub and priv:
        priv = -1;
        pub = -2;
    }
};

int main() { 
    X x;

    x.pub = 2;    // allowed
    x.priv = 1;   // won't compile; x.priv isn't accessible.

    x.do_something();    // This is no problem though.
    return 0;
}

Answer 3

通过使用公共说明符，您允许使用您的班级的任何人直接访问该班级成员。 私下中，您禁止这样做，并且用户无法直接访问它。 还有一个受保护的说明符，它允许派生类操纵该类成员。

您是正确的，类就像对象的模板一样。 创建类的实例时，您会获得“真实的”东西，即模板的实现。

Answer 4

关于您的第一点，“ Bow :: Bow（arrows）”是一个构造函数，它是类Bow的方法，负责初始化该类的实例。 您对访问修饰符的理解是正确的。 公共成员在班级之外可见，而私人成员则不可见。 受保护的成员对于从该类派生的类是可见的。

Answer 5

对象只是使用类模板来创建特定项目。

将“对象”一词替换为“构造函数”，将“项目”一词替换为“对象”。 删除“模板”一词，因为这在C ++中具有不同的含义。

公共说明符用于使数据成员在对象中可用

不完全的。 public使成员可用于对象（或类，如果它是静态成员）的客户端 。

和专用说明符用于使数据成员仅在类内部可用

基本上是正确的。