Not sure where to put my delete function without getting a segmentation fault?

I have an object MyObject with member variables that hold a name (which is what the overloaded constructor sets and a linked list of character data. I read in from a file that has a bunch of MyObjects in the following format:

name,a,b,c,d
name1,a,b,c,d,e
// etc.

My code is supposed to grab each object and add it to myVect
vector<MyObject*> myVect;

My problem is that I use new to allocate. Of course I know this means I need delete (and when I don't have delete there are memory leaks so I don't think this a double deletion issue), but no matter where I delete ptr, it cause a segmentation fault.

I would love for myVect to not hold pointers but it has to (assignment).

Here's the code

void Sequencer::ReadFile() {
  ifstream fin;
  fin.open(fileName);
  cout << "Opened File" << endl;
  string line = "";
  MyObject* ptr;
  while(getline(fin, line)) {
    string name = "";
    int count = 0;
    while(line[count] != ',') {
      name += line[count];
      count++;
    }
    ptr = new MyObject(name);
    for(int i = count + 1; i < line.size(); i+=2) {
      (*ptr).InsertEnd(line[i]);
    }
    myVect.push_back(ptr);
    //delete ptr;                                                               
    //ptr = nullptr;                                                            
  }
  //delete ptr;                                                                 
  //ptr = nullptr;                                                              
  fin.close();
}

Remember, you do not delete pointers, you delete the thing a pointer points to. That means that it doesn't make sense to delete ptr anywhere in ReadFile, since you want the pointed-to objects to continue to exist for as long as myVect holds pointers to them.

Instead you want to delete each object pointed to by the pointers in myVect whenever you're finished with them. The most common place for that is in the destructor of the object that myVect is a member of. For example:

Sequencer::~Sequencer() {
    for (MyObject* p : myVect) {
        delete p;
    }
}

Of course, if you just used smart pointers instead of raw pointers then you wouldn't need to manually delete anything. For instance, myVect could be a std::vector<std::unique_ptr<MyOjbect>>. In that case the unique_ptrs would automatically delete the object they point to when their lifetime ends.

In that case you would change ReadFile to something like this:

void Sequencer::ReadFile() {
  std::ifstream fin(fileName);
  std::string line = "";
  while(std::getline(fin, line)) {
    std::string name = "";
    int count = 0;
    while(line[count] != ',') {
      name += line[count];
      count++;
    }
    std::unique_ptr<MyObject> ptr = std::make_unique<MyObject>(name);
    for(int i = count + 1; i < line.size(); i+=2) {
      ptr->InsertEnd(line[i]);
    }
    myVect.push_back(ptr);
  }
}

That's all assuming you need pointers at all. Your current ReadFile implementation doesn't have any particular reason to dynamically allocate objects. If possible, the best solution would be to just have myVect be a std::vector<MyObject> and let std::vector handle all of the objects' lifetimes itself:

void Sequencer::ReadFile() {
  std::ifstream fin(fileName);
  std::string line = "";
  while(std::getline(fin, line)) {
    std::string name = "";
    int count = 0;
    while(line[count] != ',') {
      name += line[count];
      count++;
    }
    MyObject obj(name);
    for(int i = count + 1; i < line.size(); i+=2) {
      obj.InsertEnd(line[i]);
    }
    myVect.push_back(obj);
  }
}