Why does my class std::vector member always throw a segfault?

Question

I've searched endlessly on SE for a logical explanation for why this is happening. It is probably something very simple that I've overlooked, however I cannot spot it and would really appreciate some assistance with this.

Last week I implemented a class to read the output of a system call from a .ini file and then find and store the required information into custom objects that are then stored in a vector inside a Config class. It is a Singleton config class storing a unique_ptr for each instance of my custom class that is created.

The thing is, when I implemented this last week on my laptop, I had zero issues reading and writing to my member vector and was able to get it working exactly how I needed it. Since pulling to my desktop computer, this vector, and any STL container that I use as a member of my class, throws a segmentation fault when I try to do anything on it, even get it's size.

I've tried to shorten the code below to only include sections that actually use this vector. I have replaced my config with A, and custom class with T, and no matter where I try to use my member container, or any other test STL containers that I add to the class, I get a segfault.

For the record, I am using Qt with C++11.

Update: This example breaks on line 50 of c.cpp when debugging, and anywhere that tries to call the vector.

Debug points to this line in stl_vector.h

  // [23.2.4.2] capacity
      /**  Returns the number of elements in the %vector.  */
      size_type
      size() const _GLIBCXX_NOEXCEPT
      /*-> this line */ { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }

main.cpp

#include "c.h"

int main(int argc, char *argv[])
{

    C *c = C::getInstance();

    delete c;

    return 0;
}

t.h - Class stores information from file

#include <string>

class T
{
public:
    T();

    bool Active();

    std::string getA();
    void setA(std::string);

private:

    std::string a;
};

t.cpp

#include "t.h"

T::T()
{

}

bool T::Active()
{
    if(a == "")
    {
        return false;
    }
    return true;
}

std::string T::getA()
{
    return this->a;
}

void T::setA(std::string newa)
{
    this->a = newa;
}

c.h - Class stores T objects and parses file for information

#include "t.h"
#include <QDebug>
#include <vector>
#include <algorithm>
#include <iostream>
#include <memory>
#include <sstream>
#include <fstream>

class C
{
public:

    static C* getInstance();

private:
    C();

    static C* instance;
    static bool init;

    std::vector<std::unique_ptr<T>> t_list;
    void readLines(const std::string&);
};

c.cpp

#include "c.h"

bool C::init = false;
C* C::instance = nullptr;

C::C()
{
    system("echo this is a test command > a.ini");
    instance->readLines("a.ini");
}

C* C::getInstance()
{
    if(!init)
    {
        instance = new C;
        init = true;
    }
    return instance;
}

void C::readLines(const std::string &path)
{
    T* new_t;
    std::ifstream file(path.c_str());

    if(!file.is_open())
    {
        qDebug() << "Unable to open " << path.c_str();
    }

    std::ofstream o("test.txt");
    std::string line;
    while(std::getline(file, line))
    {
        // Split string before searching
        std::stringstream ss(line);
        std::string seg;
        std::vector<std::string> split;
        std::string left, right;

        // Search patterns
        size_t find_a = line.find("a");

        size_t del = line.find(':');

        if(find_a != std::string::npos)
        {

            o << "test_Size: " << t_list.size() << std::endl;


            if(new_t->Active())
            {
                T* temp = new_t;
                std::unique_ptr<T> move_t(temp);
                t_list.push_back(std::move(move_t));
            }

            o << "test: " << t_list.size() << std::endl;

            std::string n;

            // Check if previous ahas any null elements

            // Split string to find a
            n = line.substr(line.find("a "));
            n = n.substr(n.find(" ", +2));

            new_t->setA(n);

        }

        else
        {
            continue;
        }
    }

    // Add last a
    T* t = new_t;
    std::unique_ptr<T> move_t(t);
    //t_list.push_back(std::move(move_t));

    o << "a: " << t_list.back().get()->getA() << std::endl;
    o << t_list.size() << std::endl;

    o.close();
    file.close();

}

Answer 1

UPDATE after code change:

I see two things now: One is that new_t in C::readlines is never initialized, so this could break when new_t->Active() is called a bit later in the function. However, I believe that the main problem you're running into is in C::C(), where it says

instance->readLines("a.ini");

At this point in the execution, C::instance is not yet initialized -- you're only just constructing the object that would later be assigned to it. Because of this, this in the readlines call is invalid, and any attempt to access object members will cause UB. This latter problem can be fixed by just calling

readLines("a.ini");

in which case the currently constructed object (that will later be instance) is used for this. I have no idea what you want to happen for the first, though, so all I can say is: If you want to have a vector<unique_ptr<T>>, you will have to create objects of type T with either new T() or (arguably preferrably) std::make_unique<T>() and put them in there.

I'll also say that this is a rather ugly way to implement a singleton in C++. I mean, singletons are never really pretty, but if you're going to do it in C++, the usual way is something like the accepted answer of C++ Singleton design pattern .

Old answer:

The problem (if it is the only one, which I cannot verify because you didn't provide an MCVE) is in the lines

T move_t = new_T;
std::unique_ptr<Adapter> ptr_t(&move_t); // <-- particularly this one

m_ts.push_back(std::move(ptr_t));

You're passing a pointer to a local object into a std::unique_ptr, but the whole purpose of std::unique_ptr is to handle objects allocated with new to avoid memory leaks. Not only will the pointer you pass into it be invalid once the scope surrounding this declaration is left, even if that weren't the case the unique_ptr would attempt to delete an object that's not on the heap at the end of its lifecycle. Both problems cause undefined behavior.

To me, it looks as though you really want to use a std::vector<T> instead of std::vector<std::unique_ptr<T>>, but that's a design issue you'll have to answer yourself.

Answer 2

Answering my own question here. I am trying to call a member variable from within the constructor of the object that holds it, so the vector I am trying to access is not yet instantiated and doesn't exist in memory. That is what causes the Segmentation fault to occur, I am trying to access memory that is not allocated yet, hence any call acting on any member of my C class was causing this issue.

I fixed this problem by adding a public function to the class that then calls the private readLines() function. I call that public function from the object that will take ownership of it, and since this occurs after it has been instantiated, the memory is accessible and the problem disappears.