C++ C++；使用setter初始化，该setter接受一个输入指针，然后返回该指针的值

我已经尝试了四种不同的方法来实现这一点。我想在调用“get_all”时分配变量以捕获接口输入

---

1-由于我对模板缺乏了解而失败

#包括
#包括
#包括
使用名称空间std；
#包括
类接口{
模板结构val_t{t val；t&out；}；
地图键盘；
模板无效添加（t&out、字符串键、t值）{
KeyDict[key]={value，out}；
}
模板void get_all（）{
for（自动i=KeyDict.begin（）；i！=KeyDict.end（）；++i）{
i->second（）.out=boost:：lexical_cast（i.second（）.val）；
}
}
};
int main（）{
int i；
双d；
字符串s；
布尔b；
界面界面；
add（i，“my int”，1）；//如果不能在这里执行1，我可以执行“1”；
ui.增加（d，“我的替身”，3.14）；
添加“我的字符串”、“好东西”）；
ui.add（b，“我的布尔”，false）；
ui.get_all（）；
这行得通。谢谢你的建议，πνταῥεῖ. 这个答案是第一次和第三次尝试的组合

运行：

#包括
#包括
#包括
使用名称空间std；
类接口{
公众：
void add（int*out，string key，int val）{ui_i.sub_add（out，key，val）；}
void add（bool*out，字符串键，bool val）{ui_b.sub_add（out，键，val）；}
void add（double*out，string key，double val）{ui_d.sub_add（out，key，val）；}
void add（string*out，string key，string val）{ui_s.sub_add（out，key，val）；}
void get_all（）{
ui_i.sub_get_all（）；
ui_b.sub_get_all（）；
ui_s.sub_get_all（）；
ui_d.sub_get_all（）；
}
私人：
模板类值{
公众：
结构键\u t{
t值；
t*out；
};
地图键盘；
void sub_add（t*out，字符串键，t值）{
KeyDict[key]={value，out}；
}
void sub_get_all（）{
for（自动i=KeyDict.begin（）；i！=KeyDict.end（）；++i）{
*i->second.out=i->second.val；
}
}
};
价值观；
价值观；
价值观；
价值观；
};
int main（）{
int i；
双d；
字符串s；
布尔b；
界面界面；
ui.add（&i，“my int”，1）；//如果不能在这里执行1，我可以执行“1”；
ui.add（&d，“我的双人床”，3.14）；
添加（&s，“我的字符串”，“好东西”）；
ui.add（&b，“我的布尔”，false）；
ui.get_all（）；
这行得通。谢谢你的建议，πνταῥεῖ. 这个答案是第一次和第三次尝试的组合

运行：

#包括
#包括
#包括
使用名称空间std；
类接口{
公众：
void add（int*out，string key，int val）{ui_i.sub_add（out，key，val）；}
void add（bool*out，字符串键，bool val）{ui_b.sub_add（out，键，val）；}
void add（double*out，string key，double val）{ui_d.sub_add（out，key，val）；}
void add（string*out，string key，string val）{ui_s.sub_add（out，key，val）；}
void get_all（）{
ui_i.sub_get_all（）；
ui_b.sub_get_all（）；
ui_s.sub_get_all（）；
ui_d.sub_get_all（）；
}
私人：
模板类值{
公众：
结构键\u t{
t值；
t*out；
};
地图键盘；
void sub_add（t*out，字符串键，t值）{
KeyDict[key]={value，out}；
}
void sub_get_all（）{
for（自动i=KeyDict.begin（）；i！=KeyDict.end（）；++i）{
*i->second.out=i->second.val；
}
}
};
价值观；
价值观；
价值观；
价值观；
};
int main（）{
int i；
双d；
字符串s；
布尔b；
界面界面；
ui.add（&i，“my int”，1）；//如果不能在这里执行1，我可以执行“1”；
ui.add（&d，“我的双人床”，3.14）；
添加（&s，“我的字符串”，“好东西”）；
ui.add（&b，“我的布尔”，false）；
ui.get_all（）；
第1节中的cout:
std:：map
需要类型参数。但是
val\u t
不是一个类型（它是一个模板）。对于
add
，您需要理解模板参数推断（可能使您的参数之一成为非推断类型）@ElanHickler为什么不把整个类作为一个模板而不是单个函数的模板呢？在第1节：
std:：map
需要类型参数。但是
val\u t
不是一个类型（它是一个模板）。对于
add
你需要理解模板参数的推导（也许可以将一个参数设置为非推断类型）。@ElanHickler为什么不将整个类设置为模板，而不是将单个函数设置为模板？
#include <iostream>
#include <string>
#include <map>
using namespace std;
#include <boost/lexical_cast.hpp>

class interface {
    template <typename t> struct val_t{ t val; t& out; };

    map<string, val_t> KeyDict;

    template <typename t> void add(t& out, string key, t value) {
        KeyDict[key] ={ value, out };
    }

    template <typename t> void get_all() {
        for (auto i = KeyDict.begin(); i != KeyDict.end(); ++i) {
            i->second().out = boost::lexical_cast<t>(i.second().val);
        }
    }
};

int main() {
    int i;
    double d;
    string s;
    bool b;

    interface ui;

    ui.add(i, "my int", 1); // if it's not possible do to 1 here, I could do "1";
    ui.add(d, "my double", 3.14);
    ui.add(s, "my string", "good stuff");
    ui.add(b, "my bool", false);

    ui.get_all();

    cout <<
        "int = " << i << endl <<
        "double = " << d << endl <<
        "string = " << s << endl <<
        "bool = " << b << endl;
}

#include <iostream>
#include <string>
#include <map>
#include <boost/any.hpp>

using namespace std;

class interface {
public:

    struct any { boost::any out; boost::any val; };
    map<string, any> KeyDict;

    template <typename t> void add(t& out, string key, t defval) { KeyDict[key].out = defval; KeyDict[key].val = defval; }

    void get_all() {
        for (auto i = KeyDict.begin(); i != KeyDict.end(); ++i) 
            i->second.out = i->second.val;
    }
};

int main() {
    int i = 0;
    double d = 0;
    string s = "";
    bool b = 0;

    interface ui;

    ui.add(i, "my int", 1); // if it's not possible do to 1 here, I could do "1";
    ui.add(d, "my double", 3.14);
    ui.add(s, "my string", "good stuff");
    ui.add(b, "my bool", false);

    ui.get_all();

    cout <<
        "int = " << i << endl <<
        "double = " << d << endl <<
        "string = " << s << endl <<
        "bool = " << b << endl;

    cin.get();
}

#include <iostream>
#include <string>
#include <map>

using namespace std;

class interface {
public:
    struct typer {
        int& i_out;
        double& d_out;
        bool& b_out;
        string& s_out;

        int i = 0;
        double d = 0;
        bool b = 0;
        string s;
        char t = 0;
    };

    map<string, typer> KeyDict_i;
    map<string, typer> KeyDict_d;
    map<string, typer> KeyDict_b;
    map<string, typer> KeyDict_s;

    void add(int& out, string key, int val) { KeyDict_i[key].i_out = out; KeyDict_i[key].i = val; KeyDict_i[key].t = 'i'; }
    void add(double& out, string key, double val) { KeyDict_d[key].d_out = out; KeyDict_d[key].d = val; KeyDict_d[key].t = 'd'; }
    void add(bool& out, string key, bool val) { KeyDict_b[key].b_out = out; KeyDict_b[key].b = val; KeyDict_b[key].t = 'b'; }
    void add(string& out, string key, string val) { KeyDict_s[key].s_out = out; KeyDict_s[key].s = val; KeyDict_s[key].t = 's'; }

    void get_all() {
        for (auto i = KeyDict_i.begin(); i != KeyDict_i.end(); ++i) i->second.i_out = i->second.i;
        for (auto i = KeyDict_d.begin(); i != KeyDict_d.end(); ++i) i->second.d_out = i->second.d;
        for (auto i = KeyDict_b.begin(); i != KeyDict_b.end(); ++i) i->second.b_out = i->second.b;
        for (auto i = KeyDict_s.begin(); i != KeyDict_s.end(); ++i) i->second.s_out = i->second.s;
    }
};

int main() {
    int i = 0;
    double d = 0;
    string s = "";
    bool b = 0;

    interface ui;

    ui.add(i, "my int", 1); // if it's not possible do to 1 here, I could do "1";
    ui.add(d, "my double", 3.14);
    ui.add(s, "my string", "good stuff");
    ui.add(b, "my bool", false);

    ui.get_all();

    cout <<
        "int = " << i << endl <<
        "double = " << d << endl <<
        "string = " << s << endl <<
        "bool = " << b << endl;
}

#include <iostream>
#include <string>
#include <map>   

using namespace std;

class interface {
public:
    void add(int* out, string key, int val) { ui_i.sub_add(out, key, val); }
    void add(bool* out, string key, bool val) { ui_b.sub_add(out, key, val); }
    void add(double* out, string key, double val) { ui_d.sub_add(out, key, val); }
    void add(string* out, string key, string val) { ui_s.sub_add(out, key, val); }

    void get_all() {
        ui_i.sub_get_all();
        ui_b.sub_get_all();
        ui_s.sub_get_all();
        ui_d.sub_get_all();
    }
private:
    template <typename t> class value_dict {
    public:
        struct key_t { 
            t val;
            t* out; 
        };

        map<string, key_t> KeyDict;

        void sub_add(t *out, string key, t value) {
            KeyDict[key] ={ value, out };
        }

        void sub_get_all() {
            for (auto i = KeyDict.begin(); i != KeyDict.end(); ++i) {
                *i->second.out = i->second.val;
            }
        }
    };
    value_dict<int> ui_i;
    value_dict<bool> ui_b;
    value_dict<string> ui_s;
    value_dict<double> ui_d;
};

int main() {
    int i;
    double d;
    string s;
    bool b;

    interface ui;

    ui.add(&i, "my int", 1); // if it's not possible do to 1 here, I could do "1";
    ui.add(&d, "my double", 3.14);
    ui.add(&s, "my string", "good stuff");
    ui.add(&b, "my bool", false);

    ui.get_all();

    cout <<
        "int = " << i << endl <<
        "double = " << d << endl <<
        "string = " << s << endl <<
        "bool = " << b << endl;

    cin.get();
}