Programming

This is reproducible every time for me. It makes me think I'm missing something about malloc...

I started getting the error when I implemented the + operator.

g++ --version
g++ (GCC) 4.1.1 20061011 (Red Hat 4.1.1-30)
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.


main.cpp:

#include <iostream>
using namespace std ;

template <class T>
class MyStack
{
public:
MyStack(int = 10);
~MyStack() { delete [] stackPtr ; }
int push(const T&);
int pop(T&);
int isEmpty() const { return topnum == -1; }
int isFull() const { return topnum == size - 1; }
MyStack operator + (MyStack);
int getSize() { return size; }
private:
int size;
int topnum;
T* stackPtr;
};


template <class T>
MyStack<T> MyStack<T>::operator+ (MyStack<T> param)
{
MyStack<T> retval(size+param.getSize());
T t;
while(!isEmpty())
{
pop(t);
retval.push(t);
}
while(!param.isEmpty())
{
param.pop(t);
retval.push(t);
}
return (retval);
}

//constructor with default size 10
template <class T>
MyStack<T>::MyStack(int s)
{
size = s > 0 && s < 1000 ? s : 10;
topnum = -1;
stackPtr = new T[size] ;
}

template <class T>
int MyStack<T>::push(const T& item)
{
if (!isFull())
{
stackPtr[++topnum] = item ;
return 1;
}
return 0;
}

template <class T>
int MyStack<T>::pop(T& popValue)
{
if (!isEmpty())
{
popValue = stackPtr[topnum--];
return 1;
}
return 0;
}

int main(int argc, char **argv)
{
typedef MyStack<int> IntMyStack ;
IntMyStack is ;
int i = 10 ;
cout << "Pushing elements onto is" << endl ;
while (is.push(i))
{
cout << i << ' ' ;
i += 1 ;
}
cout << endl;
IntMyStack js;
i = 20;
cout << "Pushing elements onto js" << endl ;
while (js.push(i))
{
cout << i << ' ' ;
i += 1;
}
cout << endl;
IntMyStack ks(21);
ks = is + js;
cout << endl << "MyStack Full." << endl
<< endl << "Popping elements from ks" << endl ;
while (ks.pop(i))
cout << i << ' ' ;
cout << endl << "ks empty\n";

}


Output:
Pushing elements onto is
10 11 12 13 14 15 16 17 18 19
Pushing elements onto js
20 21 22 23 24 25 26 27 28 29

MyStack Full.

Popping elements from ks
20 21 22 23 24 25 26 27 28 29 10 11 12 13 14 15 16 17 18 19
ks empty
*** glibc detected *** ./a.out: double free or corruption (top): 0x08b320c0 ***
======= Backtrace: =========
/lib/libc.so.6[0xc18efd]
/lib/libc.so.6(cfree+0x90)[0xc1c550]
/usr/lib/libstdc++.so.6(_ZdlPv+0x21)[0x3a0d871]
/usr/lib/libstdc++.so.6(_ZdaPv+0x1d)[0x3a0d8cd]
./a.out[0x8048c58]
./a.out(__gxx_personality_v0+0x3df)[0x8048a8b]
/lib/libc.so.6(__libc_start_main+0xdc)[0xbc8f2c]
./a.out(__gxx_personality_v0+0x45)[0x80486f1]
======= Memory map: ========
00b77000-00b82000 r-xp 00000000 fd:00 6750406 /lib/libgcc_s-4.1.1-20061011.so.1
00b82000-00b83000 rwxp 0000a000 fd:00 6750406 /lib/libgcc_s-4.1.1-20061011.so.1
00b96000-00baf000 r-xp 00000000 fd:00 6751890 /lib/ld-2.5.so
00baf000-00bb0000 r-xp 00018000 fd:00 6751890 /lib/ld-2.5.so
00bb0000-00bb1000 rwxp 00019000 fd:00 6751890 /lib/ld-2.5.so
00bb3000-00cea000 r-xp 00000000 fd:00 6751891 /lib/libc-2.5.so
00cea000-00cec000 r-xp 00137000 fd:00 6751891 /lib/libc-2.5.so
00cec000-00ced000 rwxp 00139000 fd:00 6751891 /lib/libc-2.5.so
00ced000-00cf0000 rwxp 00ced000 00:00 0
00cf2000-00d17000 r-xp 00000000 fd:00 6751898 /lib/libm-2.5.so
00d17000-00d18000 r-xp 00024000 fd:00 6751898 /lib/libm-2.5.so
00d18000-00d19000 rwxp 00025000 fd:00 6751898 /lib/libm-2.5.so
00e0f000-00e10000 r-xp 00e0f000 00:00 0 [vdso]
03959000-03a3a000 r-xp 00000000 fd:00 4615137 /usr/lib/libstdc++.so.6.0.8
03a3a000-03a3e000 r-xp 000e0000 fd:00 4615137 /usr/lib/libstdc++.so.6.0.8
03a3e000-03a3f000 rwxp 000e4000 fd:00 4615137 /usr/lib/libstdc++.so.6.0.8
03a3f000-03a45000 rwxp 03a3f000 00:00 0
08048000-08049000 r-xp 00000000 fd:00 4096028 /home/coble/work/template/a.out
08049000-0804a000 rw-p 00001000 fd:00 4096028 /home/coble/work/template/a.out
08b32000-08b53000 rw-p 08b32000 00:00 0
b7e00000-b7e21000 rw-p b7e00000 00:00 0
b7e21000-b7f00000 ---p b7e21000 00:00 0
b7f15000-b7f19000 rw-p b7f15000 00:00 0
bfef1000-bff07000 rw-p bfef1000 00:00 0 [stack]
Abort

The problem seems to be your member function definition:
MyStack operator + (MyStack);
It should use a reference of MyStack as the argument as follows:
MyStack operator + (MyStack&);
Without the &, a copy of MyStack object is made and it contains a pointer to the private data member T* stackPtr. When the copy of the MyStack goes out of scope in the member function, the destructor of the MyStack object copy is called and the stackPtr is deleted. This also deletes the stackPtr of the original object because your class does not define a copy constructor to make a deep copy of the stackPtr. Then when your original object's destructor is called later, it does "delete [] stackPtr" again on an already deleted pointer. Thus the error appears.

Hi Everybody;
I am struggling for a problem in my code.I couldn't understand the source of the problem.Could you please help me?

Code:

#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>

int main (void) {
    
    DIR *dp;
       struct dirent *ep;
    char path[35] = "../";
    char tempPath[35] = "../";

    struct stat buf;
    int result;
    mode_t tempModeOfFile;

    dp = opendir (path);
    
    if (dp != NULL) {
        
    
        while ( ep = readdir (dp) ){

            printf("%s ",ep->d_name);
            
            printf("%d -- %d\t",result,buf.st_size);

            strncat(tempPath,ep->d_name,strlen(ep->d_name) );

            printf("Step2:tempPath:  <<%s>> \n",tempPath);    //## geçici satır

            if( lstat(tempPath,&buf) == -1){
                //EX 3
                printf("lstat error has occured.Program will terminated.");    
                return -8;
            }

            tempModeOfFile = buf.st_mode;

            
            strcpy( tempPath,path);            
        

        }
        
        (void) closedir (dp);
    }else
        perror ("Couldn't open the directory");
     
    
    result = closedir(dp);
    
    printf("\n closing directory: %d",result);
    

    return 0;
    
}

In working directory, there are 20 files.This code reads these 20 files successfully, but after 20th file, it can not exit from the "while" loop, instead, gives error below :

*** glibc detected *** ./adim2: double free or corruption (top): 0x08702008 ***
======= Backtrace: =========
/lib/libc.so.6[0x73eb16]
/lib/libc.so.6(cfree+0x90)[0x742070]
/lib/libc.so.6(closedir+0x28)[0x7626b8]
./adim2[0x8048717]
/lib/libc.so.6(__libc_start_main+0xdc)[0x6ebdec]
./adim2[0x8048461]
======= Memory map: ========
006b8000-006d2000 r-xp 00000000 fd:00 3735555 /lib/ld-2.5.so
006d2000-006d3000 r-xp 00019000 fd:00 3735555 /lib/ld-2.5.so
006d3000-006d4000 rwxp 0001a000 fd:00 3735555 /lib/ld-2.5.so
006d6000-00813000 r-xp 00000000 fd:00 3735584 /lib/libc-2.5.so
00813000-00815000 r-xp 0013c000 fd:00 3735584 /lib/libc-2.5.so
00815000-00816000 rwxp 0013e000 fd:00 3735584 /lib/libc-2.5.so
00816000-00819000 rwxp 00816000 00:00 0
00919000-00924000 r-xp 00000000 fd:00 3735637 /lib/libgcc_s-4.1.2-20080102.so.1
00924000-00925000 rwxp 0000a000 fd:00 3735637 /lib/libgcc_s-4.1.2-20080102.so.1
00e28000-00e29000 r-xp 00e28000 00:00 0 [vdso]
08048000-08049000 r-xp 00000000 00:16 2817420 /home/ogr/b20521751/3_odev/directory_traversal/adim2
08049000-0804a000 rw-p 00000000 00:16 2817420 /home/ogr/b20521751/3_odev/directory_traversal/adim2
08702000-08723000 rw-p 08702000 00:00 0
b7e00000-b7e21000 rw-p b7e00000 00:00 0
b7e21000-b7f00000 ---p b7e21000 00:00 0
b7f41000-b7f43000 rw-p b7f41000 00:00 0
b7f48000-b7f49000 rw-p b7f48000 00:00 0
bfbf1000-bfc07000 rw-p bfbf1000 00:00 0 [stack]
Aborted

you are asking your question in someone else thread, that is not best way to get answers

the code posted has several glaring holes, such as variables used before they are set, the closedir is called twice(?), the buffer sizes are making it prone to overflow. Is this a homework? Are you trying to learn dirent family functions?

Hello Mr Migurus;
This is a homework, but my aim is not understand the dirent family.In a part of my experiment, I have to use this.I had mistakenly close directory twice ,so it is source of problem.When remove the one of it , the problem had been solved.So I would like to appreciate you.

You had said:"you are asking your question in someone else thread, that is not best way to get answers". I couldn't understand what do you mean.

This is not my whole code ,this is a one section.So you can see variables used before they are set.
But in your message, you had mentioned about "the buffer sizes are making it prone to overflow".
Could you please describe this a bit comprehensively?
Thank you.

[QUOTE=nuri_alço;302257061] You posted in an existing topic instead of a new one. New problems should have new topics.