What is the correct way to solve HEAP CORRUPTION DETECTED in my code?

Question

What is the way arround HEAP CORRUPTION DETECTED in my code? I am trying to write a basic program using c++ object oriented programming. My code looks like this:

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

class Plant
{
public:
    Plant(void);                   // Constructor for the Plant class
    Plant(const char*);            // Overloaded constructor for the Plant class
    Plant(Plant&);                 // Copy constructor for the Plant class
    ~Plant(void)                   // Destructor for the Plant class
    {
        delete kingdom;
    }
    virtual void print(void);      // Virtual function to print information about the Plant
    void link(Plant*);             // Function to link a Plant object to the current object
    void printList(Plant*);        // Function to print a list of Plant objects
protected:
    char* kingdom;                 // Pointer to a character array representing the plant kingdom
    Plant* next;                   // Pointer to the next Plant object in the list
};

class Flower : public Plant       // Derived class Flower inheriting from the Plant class
{
public:
    Flower(const char* r = " division - Angiosperms");  // Constructor for the Flower class
    ~Flower(void)                  // Destructor for the Flower class
    {
        delete division;
    }
    virtual void print(void);      // Virtual function to print information about the Flower
private:
    char* division;                // Pointer to a character array representing the flower division
};

class ClassFlower : public Flower  // Derived class ClassFlower inheriting from the Flower class
{
public:
    ClassFlower(const char* v = "Monocotyledons");  // Constructor for the ClassFlower class
    ~ClassFlower(void)             // Destructor for the ClassFlower class
    {
        delete classFlower;
    }
    virtual void print(void);      // Virtual function to print information about the ClassFlower
private:
    char* classFlower;             // Pointer to a character array representing the flower class
};

// Definitions of class Plant member functions

Plant::Plant(void)
{
    next = 0;
    kingdom = new char[30];
    strcpy(kingdom, " the most diverse kingdom of species");
}

Plant::Plant(const char* newKingdom)
{
    next = 0;
    kingdom = new char[strlen(newKingdom) + 1];
    strcpy(kingdom, newKingdom);
}

Plant::Plant(Plant& newPlant)
{
    next = 0;
    kingdom = new char[strlen(newPlant.kingdom) + 1];
    strcpy(kingdom, newPlant.kingdom);
}

void Plant::print(void)
{
    cout << "The plant kingdom is " << kingdom << "\n";
}

void Plant::link(Plant* pt)
{
    pt->next = next;
    next = pt;
}

void Plant::printList(Plant* first)
{
    for (Plant* np = first; np; np = np->next)
        np->print();
}

// Definitions of class Flower member functions

Flower::Flower(const char* r)
{
    division = new char[strlen(r) + 1];
    strcpy(division, r);
}

void Flower::print(void)
{
    cout << "Roses are from" << division << "\n";
}

// Definitions of class ClassFlower member functions

ClassFlower::ClassFlower(const char* r)
{
    classFlower = new char[strlen(r) + 1];
    strcpy(classFlower, r);
}

void ClassFlower::print(void)
{
    Flower::print();
    cout << "from class " << classFlower << "\n";
    void getch();
}

// main function

void main(void)
{
    Plant* p;
    Plant* p1;
    Plant* a = new Plant;         // Create a Plant object using the default constructor
    Plant* u = new Flower;        // Create a Flower object using the default constructor
    Plant* m = new ClassFlower;   // Create a ClassFlower object using the default constructor

    p = a;
    Plant* list = p;
    p1 = u;
    p->link(p1);
    p = p1;
    p1 = m;
    p->link(p1);

    list->printList(list);        // Print the list of Plant objects
    delete a;                     // Free the memory for the Plant object
    //delete u;                     // Free the memory for the Flower object
    //delete m;                     // Free the memory for the ClassFlower object
    delete p1;
}

I get the error HEAP CORRUPTION DETECTED: after Normal block (#159) at 0x000001F2C954FC30. It is because I am not sure which object should be deleted at the end of main. I would appriciate any help and guidance since I am a novice at programming.

I tried deleting only a variable, and then all of the pointer variables but the error remains.

Answer 1

I'm going to put this together from my comments. But the gist is that C++ is not C, and you're doing many things (incorrectly) in a C fashion, but the C++ way completely removes the errors for you.

The issue is likely in your linked list code, but I'm not going to bother debugging it, as you should not have integrated it into your Plant class. Your code should have a single purpose. If you need a Plant class, only write Plant code for it. If you need a linked list, use std::list from <list>. Avoid C-strings and all the headache that comes from managing them manually and use std::string from <string>. This code does deal with heap memory, but you can avoid new and delete and use std::unique_ptr from <memory>.

There are other issues, like your base class destructor not being virtual. And minor nits like leaving () empty instead of writing void. That's a C-ism, and unnecessary in C++.

using namespace std; isn't saving that much time or typing, so start learning to stop using it. It will only cause headaches as the code you write gets bigger and more complex.

Other nits are less important, but contribute to better styled code. For example, protected member data is a bad idea. Issues with that data could come from any derived class, or the base. The data should be private, and getters and setters should be protected. Issues with the data lie in a single class.

And with constructors, make use of the initialization section.

Here is an example of your code with more C++ applied to it. It still uses heap memory, but has zero news and deletes because the Standard Library constructs employed do this for you.

#include <iostream>
#include <list>
#include <memory>
#include <string>

class Plant {
 public:
  Plant();
  Plant(std::string const &);
  virtual ~Plant() = default;
  virtual void print() const;

 protected:
  std::string get_kingdom() const;

 private:
  std::string kingdom;
};

class Flower : public Plant {
 public:
  Flower(std::string const &r = " division - Angiosperms");
  virtual void print() const override;

 private:
  std::string division;
};

class ClassFlower : public Flower {
 public:
  ClassFlower(std::string const &v = "Monocotyledons");

  void print() const override;

 private:
  std::string classFlower;
};

// Definitions of class Plant member functions
Plant::Plant() : kingdom(" the most diverse kingdom of species") {}

Plant::Plant(std::string const &newKingdom) : kingdom(newKingdom) {}

void Plant::print() const {
  std::cout << "The plant kingdom is" << kingdom << "\n";
}

std::string Plant::get_kingdom() const { return kingdom; }

// Definitions of class Flower member functions
Flower::Flower(std::string const &r) : division(r) {}

void Flower::print() const {
  std::cout << "Roses are from" << division << "\n";
}

// Definitions of class ClassFlower member functions
ClassFlower::ClassFlower(std::string const &r) : classFlower(r) {}

void ClassFlower::print() const {
  Flower::print();
  std::cout << "from class " << classFlower << "\n";
}

// main function

int main() {
  std::list<std::unique_ptr<Plant>> plantList;

  plantList.emplace_back(std::make_unique<Plant>());
  plantList.emplace_back(std::make_unique<Flower>());
  plantList.emplace_back(std::make_unique<ClassFlower>());

  for (auto const &plant : plantList) {
    plant->print();
    std::cout << '\n';
  }
}