Reading configuration from a file for video rendering
I see a number of things that could help you improve your code.

Make sure you include all required headers

The necessary headers are not included in the question which makes it a bit harder to review than it needs to be.  The standard ones that are required appear to be these:

#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;sstream&gt;


Pass file names as parameters

Rather than hardcoding a filename twice (leading to the potential error of not having them match!), pass it as a parameter instead.  This reduces the hidden linkages in the code and makes it easier to see what's happening.

Be careful with signed versus unsigned

The code currently contains this:

for (int i = 0; i &lt; contents.length();i++){
    if (!(contents[i] &gt;= '0' &amp;&amp; contents[i] &lt;= '9' || contents[i] == ' ')) 
        return false;
}
MySettings = std::stoi(contents);


However, on some platforms, size_t is unsigned, so the loop is comparing an unsigned and a signed number.  I'd avoid that problem by declaring i to be of type size_t.

Use nullptr rather than NULL

Modern C++ uses nullptr rather than NULL.  See this answer for why and how it's useful.  Once you do that, you'll see that you have been abusing NULL and using it as an integer value instead of just a pointer.  For example, the code includes this:

int pos1 = NULL, pos2 = NULL;


In that context, both of those should be 0 because the variables are not pointers.

Use namespaces when required

The std namespace is used in some locations within the code, but not all.  In particular, in this line:

fstream input("config.ini", fstream::in);


Needed to be converted to this to compile on my machine:

std::fstream input("config.ini", std::ios::in);


Create a default constructor

In the case there is no config file, you'd like to have some default settings.  The better way to do that is to have a default constructor for Config.  I'd write it like this:

Config() : renderer{1}, Width{640}, Height{480}, Fullscreen{0} {}


Create a stream inserter

At some point, you will undoubtedly want to write the configuration file.  To do that, I'd recommend writing a stream inserter like this:

friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp; out, const Config&amp; cfg) {
    return out &lt;&lt; "//renderer options - 0: D3D8, 1: D3D9, 2: OpenGL"
        "\nwidth=" &lt;&lt; cfg.Width &lt;&lt; 
        "\nheight=" &lt;&lt; cfg.Height &lt;&lt; 
        "\nfullscreen=" &lt;&lt; (cfg.Fullscreen ? 1 :0 ) &lt;&lt; 
        "\nrenderer=" &lt;&lt; cfg.renderer &lt;&lt; '\n';
}


Eliminate goto

The above two suggestions allow you to eliminate the start label and the associate goto by writing the else clause like this:

else{
    std::ofstream out(filename);
    out &lt;&lt; MySettings;
}


Use standard algorithms to simplify

The code contains ConfigValue which returns a bool indicating whether the configuration was updated.  However, a more generic way to handle this might instead be to write a function to take a line and extract a name, value pair.  Here's how I'd write such a function:

std::pair&lt;std::string, int&gt; value(std::string line) {
    std::pair&lt;std::string, int&gt; val;
    // remove any comments
    auto n = line.find("//");
    if (n != std::string::npos) {
        line.erase(n);
    n = line.find('=');
    if (n != std::string::npos) {
        line[n] = ' ';  // replace '=' with space
        std::stringstream ss(line);
        ss &gt;&gt; val.first &gt;&gt; val.second;
    }
    return val;
}


Write a stream extractor

In the same spirit as writing the stream inserter, we can write a stream extractor.  Using the value function above as a member function of Config, it could be this:

friend std::istream&amp; operator&gt;&gt;(std::istream&amp; in, Config&amp; cfg) {
    Config temp;
    std::string line;
    int fields = 0xF;
    for (std::string line; fields &amp;&amp; std::getline(in, line); ) {
        auto pair=temp.value(line);
        if (pair.first == "width") {
            temp.Width = pair.second;
            fields &amp;= ~0x01;
        } else if (pair.first == "height") {
            temp.Height = pair.second; 
            fields &amp;= ~0x02;
        } else if (pair.first == "renderer") {
            temp.renderer = pair.second; 
            fields &amp;= ~0x04;
        } else if (pair.first == "fullscreen") {
            temp.Fullscreen = pair.second; 
            fields &amp;= ~0x08;
        }
    }
    if (fields == 0) {
        std::swap(temp, cfg);
    } else {
        in.setstate(std::ios::failbit);
    }
    return in;
}


Note that unlike the current code, this code only updates the default if all four values were successfully read.  If you don't want that, you can just omit all references to fields in this function.  

Make the object take care of itself

Since all of this code is associated with the Config struct, why not just actually make it a C++ class and have it take care of its own initialization?  For that, we could replace the ConfigFile function with a constructor:

Config(const std::string&amp; filename)
: renderer{1}, Width{640}, Height{480}, Fullscreen{0} 
{
     std::ifstream input(filename);
    input &gt;&gt; *this;
    if (!input) {
        std::ofstream out(filename);
        out &lt;&lt; *this;
    }
}


Test function

I created a sample main to drive this code.  It looks like this:

int main()
{
    Config cfg("configreader.test");
    std::cout &lt;&lt; cfg;
}


Naturally, you'll want to add more error and range checking but I hope this inspires you to rework your code into something more object-oriented.