Destructor Issue

I'm having problems with a destructor. It says my heap is corrupted and after debugging I'm assuming that this is the problem. It is after a certain function so here's that function:

Code:

---

#include "stdafx.h"
#include <string>
#include <iostream>
#include <fstream>
#include <stdlib.h>
#include "string.h"

#define NULL "\0"


extern std::ofstream csis;

//Default Ctor

String::String()
{
        m_buf = new char[1];
        m_length = 1;
        m_buf[0] = '\0';
       
        m_name = "";
}

//Ctor with string literal param
String::String(char* s)
{
        int inputString = strlen(s);
        inputString++;

        m_length = inputString;

        m_buf = new char[inputString];

        strcpy_s(m_buf, m_length, s);
       
        m_name = "";
}

//Ctor with single char as param
String::String(char c)
{
        m_buf = new char[2];

        m_buf[0] = c;
        m_buf[1] = '\0';

        int inputString = strlen(m_buf);

        m_length = inputString;
       
        m_name = "";
}

String::String(int x)
{
        m_buf = new char[sizeof(x)];

        _itoa(x, m_buf, 10);

        m_length = strlen(m_buf);

        m_name = "";
}

//Ctor with pointer to data member
String::String(const String& s)
{
        m_length = s.m_length;
        m_length;
        m_buf = new char[m_length];

        strcpy_s(m_buf, m_length, s.m_buf);

        m_name = "";
}


//Ctor with repeating char
String::String(char c, int x)
{
        m_buf = new char[x];
       
        for(int i =0; i < x; i++)
        {
                m_buf[i] = c;
        }

        m_buf[x] = '\0';

        m_length = strlen(m_buf);

        m_name = "";
}

//Destructor
String::~String()
{
        if(m_name)
                delete[]m_name;
        if(m_buf)
                delete[]m_buf;

}
......

---

The error occurs after the last constructor function and at delet[]m_buf in the destructor. The actual error is: Heap corruption detected.....detected that the program wrote to the memory after the end of heap buffer....

Any thoughts please and thank you?

This is probably it:

Code:

---

m_buf = new char[x];
       
// loop through m_buf

m_buf[x] = '\0';

---

m_buf has x characters, but x isn't a safe index. It's one past the memory you asked for.

that one is wrong

Code:

---

String::String(int x) {
        m_buf = new char[sizeof(x)];
        _itoa(x, m_buf, 10);
        m_length = strlen(m_buf);
        m_name = "";
}

---

sizeof(x) doesn't tell you how many chars are needed to represent an int as string.
that one as well

Code:

---

String::String(char c, int x) {
        m_buf = new char[x];
        for(int i =0; i < x; i++) {
                m_buf[i] = c;
        }
        m_buf[x] = '\0';
        m_length = strlen(m_buf);
        m_name = "";
}

---

you allocate only x chars but then you assigne '\0' to the n+1 char.

same thing with the copy constructor. the buffer is too small.

also you have to implement an assignement operator. the compiler generated one will create memory-leaks and double deletes in the destructor.
Kurt

> m_name = "";
Well you can't delete this.

You're better off saying
m_name = NULL;

> if(m_name)
You don't need this either, because deleting NULL is safe.

> int inputString = strlen(s);
I find inputString to be a very confusing variable name, given its context.

I fixed the x char issue..... I debugged again and at my assignment operator is where i"m having the problem I guess. I have something assigns a string to two others to String s7, t7, u7....then String s7("whatever")....then s7 = t7 = u7; Then when my destructor is called at m_buf it says there is writing past the heap buffer. Here's that assignment operator and my destructor again:

Code:

---

String& String::operator=(const String& rhs)
{
        m_length = rhs.m_length;

        strcpy_s(m_buf, m_length, rhs.m_buf);
       
        return *this;
}

//Destructor
String::~String()
{
        delete[]m_buf;
        delete[]m_name;

}

---

And what about all your constructors?
Are they still assigning bogus pointers which can't be deleted?

try something like this

Code:

---

String& String::operator=(const String& rhs) {
        // we don't want self assignement
        if ( this != &rhs ) {
            // free old buffer
            delete [] m_buf;
            m_length = rhs.m_length;
            // need space for '\0'
            m_buf = new char[m_length + 1];
            // don't know that one. looks strange
            strcpy_s(m_buf, m_length, rhs.m_buf);
            // what about m_name ?
        }
        return *this;
}

---

Kurt