C++ 我应该如何处理只应由工厂类使用的setter方法？

我使用一个工厂类从内存池生成许多小类。这些小类在工厂返回后是常量

目前，这些小对象之一的典型声明如下：

class LittleObject
{
public:
    ...//non-getter and setter member functions
    int getMemberVariable1() const;//should be accessible to everyone
    void setMemberVariable1(int newMemberVariable1Value);//should only be accessible to factory class
    ...//more getters and setters
private:
    ...
};

所以，正如你所看到的，接球手和二传手都在公共区域。但是，应该设置这些值的唯一时间是在factory类构建它的过程中。现在，我可以清楚地看到一个选项，我将setter函数移动到私有访问，并使工厂成为LittleObject类的朋友。我觉得这个选项有点不雅观，因为它向工厂公开了其他私有成员函数。工厂无权访问的私有成员函数

所以我的问题是：什么是最好的方法，只有factory类才能使用setter函数？我会使用：

我会使用：

---

您可以使工厂成为每个对象的静态成员函数。因此，每个对象类型都知道如何创建自己。然后，您可以使用某种模板函数来减少创建模板的输入

有点像这样：

class LittleObject1
{
    int a = 0;
    int b = 0;

public:
    virtual ~LittleObject1() {}

    static LittleObject1* create()
    {
        LittleObject1* o = new LittleObject1;
        o->a = 1;
        o->b = 2;
        return o;
    }
};

class LittleObject2
{
    std::string s;

public:
    virtual ~LittleObject2() {}

    static LittleObject2* create()
    {
        LittleObject2* o = new LittleObject2;
        o->s = "hello";
        return o;
    }
};

template<typename Type>
Type* createType(Type*)
{
    return Type::create();
}

int main()
{
    LittleObject1* o1 = createType(o1);
    LittleObject2* o2 = createType(o2);
}

类LittleObject1
{
int a=0；
int b=0；
公众：
虚拟~LittleObject1（）{}
静态LittleObject1*创建（）
{
LittleObject1*o=新的LittleObject1；
o->a=1；
o->b=2；
返回o；
}
};
类LittleObject2
{
std：：字符串s；
公众：
虚拟~LittleObject2（）{}
静态LittleObject2*创建（）
{
LittleObject2*o=新的LittleObject2；
o->s=“你好”；
返回o；
}
};
模板
类型*创建类型（类型*）
{
返回类型：：create（）；
}
int main（）
{
LittleObject1*o1=createType（o1）；
LittleObject2*o2=createType（o2）；
}

您可以使工厂成为每个对象的静态成员函数。因此，每个对象类型都知道如何创建自己。然后，您可以使用某种模板函数来减少创建模板的输入

有点像这样：

class LittleObject1
{
    int a = 0;
    int b = 0;

public:
    virtual ~LittleObject1() {}

    static LittleObject1* create()
    {
        LittleObject1* o = new LittleObject1;
        o->a = 1;
        o->b = 2;
        return o;
    }
};

class LittleObject2
{
    std::string s;

public:
    virtual ~LittleObject2() {}

    static LittleObject2* create()
    {
        LittleObject2* o = new LittleObject2;
        o->s = "hello";
        return o;
    }
};

template<typename Type>
Type* createType(Type*)
{
    return Type::create();
}

int main()
{
    LittleObject1* o1 = createType(o1);
    LittleObject2* o2 = createType(o2);
}

类LittleObject1
{
int a=0；
int b=0；
公众：
虚拟~LittleObject1（）{}
静态LittleObject1*创建（）
{
LittleObject1*o=新的LittleObject1；
o->a=1；
o->b=2；
返回o；
}
};
类LittleObject2
{
std：：字符串s；
公众：
虚拟~LittleObject2（）{}
静态LittleObject2*创建（）
{
LittleObject2*o=新的LittleObject2；
o->s=“你好”；
返回o；
}
};
模板
类型*创建类型（类型*）
{
返回类型：：create（）；
}
int main（）
{
LittleObject1*o1=createType（o1）；
LittleObject2*o2=createType（o2）；
}

我真的更喜欢

朋友

工厂，但如果你需要更强的
封装，以牺牲优雅为代价，也许可以做到

struct LittleData;

class Factory
{
public:
    void MakeLittle(LittleData&);
};

struct LittleData
{
    int data1;
    float data2;
};

class LittleObject
{
public:
    LittleObject(const LittleObject&) = default;
    LittleObject& operator=(const LittleObject&) = default;

    int GetData1() const { return data.data1; }
    float GetData2() const { return data.data2; }

    static LittleObject MakeOne( Factory& f )
    {
        LittleObject obj;
        f.MakeLittle(obj.data);
        return obj;
    }
private:
    LittleObject();
    LittleData data;
};

---

看看我刚才写的。。。我真的更喜欢

friend

我真的更喜欢

friend

工厂，但是如果你需要更强的
封装，以牺牲优雅为代价，也许可以做到

struct LittleData;

class Factory
{
public:
    void MakeLittle(LittleData&);
};

struct LittleData
{
    int data1;
    float data2;
};

class LittleObject
{
public:
    LittleObject(const LittleObject&) = default;
    LittleObject& operator=(const LittleObject&) = default;

    int GetData1() const { return data.data1; }
    float GetData2() const { return data.data2; }

    static LittleObject MakeOne( Factory& f )
    {
        LittleObject obj;
        f.MakeLittle(obj.data);
        return obj;
    }
private:
    LittleObject();
    LittleData data;
};

---

看看我刚才写的。。。我真的更喜欢

朋友

另一种可能性是模具

我指的是每个

LittleObject

的静态实例预设为所需的配置，以便工厂只需制作一个副本

可以通过复制构造函数进行复制，或者，如果您不想创建其中一个（并且对象很小），则可以使用

memcpy（）

下面是一个使用复制构造函数的示例：

class LittleObject1
{
    int a;
    int b;

public:
    LittleObject1(const LittleObject1& o): a(o.a), b(o.b) {}
    LittleObject1(int a = 0, int b = 0): a(a), b(b) {}

    static LittleObject1 stencil;

    int get_a() const { return a; }
    int get_b() const { return b; }
};

LittleObject1 LittleObject1::stencil(3, 7); // preset values

class LittleObject2
{
    std::string s;

public:
    LittleObject2(const LittleObject2& o): s(o.s) {}
    LittleObject2(const std::string& s = ""): s(s) {}

    static LittleObject2 stencil;

    std::string get_s() const { return s; }
};

LittleObject2 LittleObject2::stencil("hello"); // preset values

class Factory
{
public:

    template<typename Type>
    Type* create() const
    {
        return new Type(Type::stencil); // make a copy of the preset here
    }
};

int main()
{
    Factory fact;

    LittleObject1* o1 = fact.create<LittleObject1>();

    std::cout << o1->get_a() << '\n';
    std::cout << o1->get_b() << '\n';

    LittleObject2* o2 = fact.create<LittleObject2>();

    std::cout << o2->get_s() << '\n';
}

类LittleObject1
{
INTA；
int b；
公众：
LittleObject1（const LittleObject1&o）：a（o.a），b（o.b）{}
LittleObject1（inta=0，intb=0）：a（a），b（b）{}
静态LittleObject1模板；
int get_a（）常量{return a；}
int get_b（）常量{return b；}
};
LittleObject1 LittleObject1:：模具（3,7）；//预设值
类LittleObject2
{
std：：字符串s；
公众：
LittleObject2（const LittleObject2&o）：s（o.s）{
LittleObject2（const std:：string&s=“”）：s（s）{
静态LittleObject2模板；
std:：string get_s（）const{return s；}
};
LittleObject2 LittleObject2:：模具（“你好”）；//预设值
阶级工厂
{
公众：
模板
类型*create（）常量
{
返回新类型（Type:：stencil）；//在此处复制预设
}
};
int main（）
{
工厂事实；
LittleObject1*o1=fact.create（）；
std:：cout_a（）另一种可能性是模具

我指的是每个
LittleObject
的静态实例预设为所需的配置，以便工厂只需制作一个副本

可以通过复制构造函数进行复制，或者，如果您不想创建其中一个（并且对象很小），则可以使用
memcpy（）

下面是一个使用复制构造函数的示例：

class LittleObject1
{
    int a;
    int b;

public:
    LittleObject1(const LittleObject1& o): a(o.a), b(o.b) {}
    LittleObject1(int a = 0, int b = 0): a(a), b(b) {}

    static LittleObject1 stencil;

    int get_a() const { return a; }
    int get_b() const { return b; }
};

LittleObject1 LittleObject1::stencil(3, 7); // preset values

class LittleObject2
{
    std::string s;

public:
    LittleObject2(const LittleObject2& o): s(o.s) {}
    LittleObject2(const std::string& s = ""): s(s) {}

    static LittleObject2 stencil;

    std::string get_s() const { return s; }
};

LittleObject2 LittleObject2::stencil("hello"); // preset values

class Factory
{
public:

    template<typename Type>
    Type* create() const
    {
        return new Type(Type::stencil); // make a copy of the preset here
    }
};

int main()
{
    Factory fact;

    LittleObject1* o1 = fact.create<LittleObject1>();

    std::cout << o1->get_a() << '\n';
    std::cout << o1->get_b() << '\n';

    LittleObject2* o2 = fact.create<LittleObject2>();

    std::cout << o2->get_s() << '\n';
}

类LittleObject1
{
INTA；
int b；
公众：
LittleObject1（const LittleObject1&o）：a（o.a），b（o.b）{}
LittleObject1（inta=0，intb=0）：a（a），b（b）{}
静态LittleObject1模板；
int get_a（）常量{return a；}
int get_b（）常量{return b；}
};
LittleObject1 LittleObject1:：模具（3，7）；//预设值
类LittleObject2
{
std：：字符串s；
公众：
LittleObject2（const LittleObject2&o）：s（o.s）{
LittleObject2（const std:：string&s=“”）：s（s）{
静态LittleObject2模板；
std:：string get_s（）const{return s；}
};
LittleObject2 LittleObject2:：模具（“hello”）；//预设值
阶级工厂
{
公众：
模板
类型*create（）常量
{
返回新类型（Type:：stencil）；//在此处复制预设
}
};
int main（）
{
工厂事实；
LittleObject1*o1=fact.create（）；
std：：无法获取a（）依赖常量正确性

你