Wierd situtation is causing segmentation fault

Question

Below is a very simple driver code for stack implementation I wrote:

#include <iostream>
#include <string>
#include "stack.h"
#include "vector.h"
 
void print(stack<std::string, vector<std::string>> stk)
{}
 
int main()
{
    vector<std::string>
        v1{"1","2","3","4"},
        v2{"Ɐ","B","Ɔ","D","Ǝ"};
 
    stack<std::string, vector<std::string>> s1{std::move(v1)};
    stack<std::string, vector<std::string>> s2{std::move(v2)};
 
    print(s1);
    print(s1);
    print(s2);
}

For some very weird reason, it crashes at runtime complaining about segmentation fault. For even more strange reason, the following works (and so does a few other orderings of print(sx) statements:

#include <iostream>
#include <string>
#include "stack.h"
#include "vector.h"
 
void print(stack<std::string, vector<std::string>> stk)
{}
 
int main()
{
    vector<std::string>
        v1{"1","2","3","4"},
        v2{"Ɐ","B","Ɔ","D","Ǝ"};
 
    stack<std::string, vector<std::string>> s1{std::move(v1)};
    stack<std::string, vector<std::string>> s2{std::move(v2)};
 
    print(s1);
    //print(s1);
    print(s2);
}

In case, you are wondering, why am I using vector instead of std::vector; I wrote my own vector class too. Thanks to Sam Varshavchik comment, the problem might be in the vector class. This is the link to it: vector

My machine specifications:

• Ubuntu 22.04 LTS
• GCC 11.2.0
• -std = c++11
• Compiled with g++ main.cc -o main.out (nothing fancy)

stack.h

#ifndef STACK_H
#define STACK_H

#include <utility>
#include <deque>

template<typename T, class Sequence = std::deque<T>>
class stack
{
public:
    typedef          Sequence                   container_type;
    typedef typename Sequence::value_type       value_type;
    typedef typename Sequence::reference        reference;
    typedef typename Sequence::const_reference  const_reference;
    typedef typename Sequence::size_type        size_type;

    stack() : c(Sequence()) {}
    explicit stack(const Sequence& __c) : c(__c) {}
    explicit stack(Sequence&& __c) : c(std::move(__c)) {}
    stack(const stack& __s) : c(__s.c) {}
    stack(stack&& __s) : c(std::move(__s.c)) {}
    ~stack() {}

    stack& operator=(const stack& __s)
    {
        c = __s.c;
        return *this;
    }
    stack& operator=(stack&& __s)
    {
        c = std::move(__s.c);
        return *this;
    }

    bool empty() const { return c.empty(); }
    size_type size() const { return c.size(); }
    reference top() { return c.back(); }
    const_reference top() const { return c.back(); }
    void push(const value_type& __x) { c.push_back(__x); }
    void push(value_type&& __x) { c.push_back(std::move(__x)); }
    void pop() { c.pop_back(); }
    void swap(stack& __s) { std::swap(c, __s.c); }

    inline bool operator==(const stack& __s) { return c == __s.c; }
    inline bool operator!=(const stack& __s) { return c != __s.c; }
    inline bool operator<(const stack& __s) { return c < __s.c; }
    inline bool operator<=(const stack& __s) { return c <= __s.c; }
    inline bool operator>(const stack& __s) { return c > __s.c; }
    inline bool operator>=(const stack& __s) { return c >= __s.c; }

protected:
    Sequence c;
};

#endif

Answer 1

Your vector class defines these two constructors which are very sketchy:

vector(const vector& x) : __size(x.__size), __capacity(x.__capacity)
{
    delete [] __base;
    __base = new value_type[__capacity];
    for(size_type __c = 0; __c != __size; ++__c)
        __base[__c] = x.__base[__c];
}

vector(std::initializer_list<value_type> il) : __size(il.size()), __capacity(__size << 1)
{
    delete [] __base;
    __base = new value_type[__capacity];
    typename std::initializer_list<value_type>::iterator itr = il.begin();
    typename std::initializer_list<value_type>::iterator end = il.end();
    for(size_type __c = 0; __c != __size && itr != end; ++__c, ++itr)
        __base[__c] = *itr;
}

Why are they sketchy? Glad you asked! The member vector::__base is uninitialized at the point where you call the following:

delete [] __base;

Because __base has no defined value at this point, the behavior of deleting it is undefined. If it was NULL, this wouldn't be an issue.

Now, there really is no good reason to delete a member in your constructor. It will never have a value other than what you initialize it with. My guess is that you copy/pasted the code from your assignment operator, thus creating a serious bug.

To fix, you have two main options:

1. Remove the delete[] __base; statement
2. Add __base(nullptr) to the initializer list

The way your class is currently written, you should probably go with #1. However, if you were to extract your duplicated code from the copy constructor and assignment operator into a single helper method, it might always use delete[] and so you would likely go with option #2.

Just a side-note here... There's also a potential problem with your assignment operator. It should be testing for self assignment, otherwise assigning a vector to itself will completely break it:

vector& operator=(const vector& x)
{
    if (&x == this) return *this;

    // etc...
}