封装数据，使setter是私有的，getter是公共的 我想知道如何最好地在C++中创建一个数据实体，其中“SETter”是私有的，“GETter”是公共的。i、 e实体的创建者应该能够设置数据，但用户/消费者/客户机只能获取数据 让我们考虑实体EntIXX： class EntityX { public: EntityX(int x, int y) : x(x), y(y) {} int GetX() const {return x;} int GetY() const {return y;} private: int x,y; // Effective C++ third edition, Item 22: Declare data members private }

以及创建实体并将其返回给客户端的类方法：

const shared_ptr<EntityX> classz::GetEntityX()
{
  shared_ptr<EntityX> entity(new EntityX(1,2));

  return entity;
}

const shared_ptr classz:：GetEntityX（） { 共享ptr实体（新实体x（1,2））； 返回实体； } 在我看来，这使得setter是私有的，getter是公共的，但是如果数据成员大于5-10，那么这个例子就不实用了。。。如何创建一个实体类/结构，使setter为“private”，getter为“public”，而不使构造函数接受所有数据成员变量

提前感谢

将您的创建者设置为

朋友

到

类EntityX

：

   class EntityX
    {
      friend class Creator;
      public:
        EntityX(int x, int y) : x(x), y(y)
        {}
        int GetX() const {return x;}
        int GetY() const {return y;}
      private:
        int x,y; // Effective C++ third edition, Item 22: Declare data members private
    };

---

更新：

或者您可以使用模板化的friend ship，请参见下面的代码：

#include <iostream>
#include <memory>

template<class T>
class EntityX
  {
  friend T;
  public:
    EntityX(int x, int y) : x(x), y(y) {}
    int GetX() const {return x;}
    int GetY() const {return y;}
  private:
    int x,y; // Effective C++ third edition, Item 22: Declare data members private
  };

struct Creator
  {
    static const std::shared_ptr<EntityX<Creator>> create() 
      {  
      std::shared_ptr<EntityX<Creator>> entity = std::make_shared<EntityX<Creator>>(1,2);
      entity->x = 1;
      entity->y = 2;
      return entity;
      }
  };

int main()
{
  std::shared_ptr<EntityX<Creator>> const E = Creator::create();
  std::cout << E->GetX() << ", " << E->GetY() << std::endl;

  return 0 ; 
}

#包括
#包括
模板
类实体
{
朋友T；
公众：
EntityX（intx，inty）：x（x），y（y）{
int GetX（）常量{return x；}
int GetY（）常量{return y；}
私人：
int x，y；/c++ C++第三版，项目22：声明数据成员私有
};
结构创建者
{
静态常量std:：shared_ptr create（）
{  
std:：shared_ptr entity=std:：make_shared（1,2）；
实体->x=1；
实体->y=2；
返回实体；
}
};
int main（）
{
std:：shared_ptr const E=Creator:：create（）；
std:：cout GetX（）您的getter可以返回常量&so

public:
int const& Getter();
private:
int const& Setter(int value);

用变量名替换“setter”和“getter”

public:
int const& X();
private:
int const& X(int value);

你也可以用这个语法写同样的东西

const int& X();

只是你想怎么写的问题

祝你好运，我希望我能帮上忙。
像这样的事情怎么样：

struct EntityValues
{
   Type1 value1_;
   Type2 value2_;
   (etc for all the members of Entity
};

class Entity
{
  public:
    Entity () : <set default values> 
    {
    }

    // this avoids the sea-of-parameters problem by bundling the data values
    // into a single parameter.  Data can be added to values by name in random order
    // before it is finally used here.
    Entity(const EntityValues & values) : <set members by pulling data from values>
    {

    }

    // individual public getters.
    Type1 getValue1()const { return value1_;}
    <repeat as necessary for other members>

    // get everything at once 
    // (an alternative to individual getters)
    // 
    void exportValues(EntityValues & values) const
    {
       <copy member to values>
    }

    // optional (this violates the "no public setters" constraint
    // but it does it in a controlled manner.
    void update(const EntityValues & values)
    {
       <set members by pulling data from values>
    }

private:
    <setters (if necessary) and members go here
 };

struct EntityValues
{
类型1值1；
类型2值2；
（等）实体的所有成员
};
类实体
{
公众：
实体（）：
{
}
//这通过捆绑数据值避免了参数海洋问题
//数据可以按名称以随机顺序添加到值中
//在这里最后使用之前。
实体（常量实体值和值）：
{
}
//个人公众获得者。
Type1 getValue1（）常量{return value1_；}
//立即得到一切
//（单个getter的替代方案）
// 
void exportValues（EntityValues和values）常量
{
}
//可选（这违反了“无公共设置器”约束
//但它是以可控的方式进行的。
无效更新（常量实体值和值）
{
}
私人：
我想，对于您不希望其他人更改的成员变量，只提供一个getter成员函数而不提供setter成员函数。我不希望实体类包含数据以外的任何内容。类的创建者必须提供所有数据o？为什么需要setter？您拥有的默认构造函数应该可以满足您的需要s、 不需要任何二传，私人或其他。康斯特内斯或朋友（船）因为我不知道所有的创建者…可能有数百个。例如，资源类进行数据库查询并返回一个EntityX类型的数据行。实体类EntityX无法查询数据，它只能包含数据，如果这有意义的话…@user3594184我现在不确定，但可能是Contin中的一个模板朋友类如果Setter是私有的，实体类的创建者就不能访问私有函数谢谢，我想我错过了问题的这一部分。我会重新考虑我的答案