c++ enforcing namespace compliance - c++

Question

Suppose you have a namespace
approvedParams {
std::string s1 = "my_string_input_1";
std::string s2 = "my_string_input_2";
}
Outside the scope of approvedParams there exists a function myfun(std::string parm1)
Is it possible to constrain myfun signature to only accept fields of type std::string from the approvedParams namespace?
That is:
myfun("my_string_input_1") will not compile.
myfun(approvedParams::s1) will compile.
I was considering an implementation with enum. However I ultimately want use approvedParams::s1 and s2 when I am parsing key-value configuration files. enum must be of an integral type. I am not interested in adding another unnecessary layer with map<int,std::string> to connect the enum integers with std::string.

Answer 1

The type of s1 and s2 do not carry information about the namespace they were declared in.
You could rather easily wrap a custom type though.
namespace approvedParams
{
struct keytype { std::string val; };
keytype s1 = { "my_string_input_1" };
keytype s2 = { "my_string_input_2" };
}
void approvedParams( approvedParams::keytype );

Answer 2

Create an enum of approved parameter values
enum approvedParams {
val1 = 0,
val2, ...
};
And just create an array with the string using these indexes
std::string[] approvedParamValues = { "my_string_input_1", ... };

Answer 3

Here's my take at it, reusing #DrewDormann's idea of a wrapper type but in a way that actually enforces its usage.
The idea is basically a variant of the named constructor idiom, but only with static variables instead of fully-fledged factory functions (does this pattern have a name?).
// Declaration in .h
class ApprovedParam
{
public:
static const ApprovedParam foo;
static const ApprovedParam bar;
const std::string& value() const { return m_value; }
private:
std::string m_value;
ApprovedParam(const char* value) : m_value(value) {}
ApprovedParam(std::string&& value) : m_value(std::move(value)) {}
ApprovedParam(const std::string& value) : m_value(value) {}
// IMPORTANT: the user must not be able to default construct an ApprovedParam
ApprovedParam() = delete;
};
// Definitions in .cpp
const ApprovedParam ApprovedParam::foo = "foo";
const ApprovedParam ApprovedParam::bar = "bar";
Now the user can copy/move/assign ApprovedParam objects but he has only a limited set of (immutable) instances to choose from and he will not be able to create completely new ones.