Question: For an application that uses a number of environment variables, is there some kind of a convention or "best practice" when it comes to grabbing environment variables and putting them into either a struct or a bunch of `const`'s? Obviously, I want to fallback to a default value for each and every environment variable. Right now, using the following seems like a very messy way of doing it:

```
char* x;
const SOME_VARIABLE;
if (NULL == (x = getenv("SOME_VARIABLE")))
    SOME_VARIABLE = 5; // default value
else
    SOME_VARIABLE = x;

```

I could also write a function that wraps `getenv` to return a default value if an environment variable is empty, but I'm not sure if that's even the best way to do it. I could also do away with using `const`, but that doesn't seem like a good thing to do, either.

Any thoughts?

Answer: 
How about:

```
std::string GetEnvironmentVariableOrDefault(const std::string& variable_name, 
                                            const std::string& default_value)
{
    const char* value = getenv(variable_name.c_str());
    return value ? value : default_value;
}

```

Used as:

```
const std::string some_variable = GetEnvironmentVariableOrDefault("SOME_VARIABLE", "5");

```
[James McNellis](https://stackoverflow.com/users/151292/james-mcnellis) has provided a [great answer](https://stackoverflow.com/questions/3936212/c-assign-const-to-environment-variable-or-default-value/3936267#3936267), but here is an alternate opinion:

I think `getenv()` returns the value of the environment variable at the time the program was started. If the environment variable gets changed after the program is started, `getenv()` would still return the old value. Based on that, an alternate approach may be to have a class to capture all the required environment variables as attributes. The class is populated at the start of the program, and provides only (const-qualified) accessor methods. That way the `getenv()` is called **exactly once** for each environment variable. On the negative side, the class takes up some space. 

In the alternate approach, which does not use any space, `getenv()` is called whenever the value of any environment variable is required. It’s not that the `getenv()` call is expensive (actually I don’t’ know), but it carries a false assumption to the programmer that the latest value might be returned. 

Also having a class may be useful to abstract if there is any dependency in using the environement variables, e.g. 

```
if $OS = "SunOs" 
then 
    GCC="/bin/gcc" 
else 
    GCC="/usr/bin/gcc" 

(this is just an example though)

```

Now, a function who don’t care about `$OS` but needs only `$GCC`, can just refer to `envClass->get("GCC");`

Just a thought.