Getting confused by a simple program

[pim42]

Ok so I think I'm having trouble with a class in my program so I created a small program to try to see what is going on. I am confused by the results. It seems that just when I think I understand C++ and OOP I find out I have been doing something wrong.
This is my BaseData class( in base.h):
class BaseData
{
public:
BaseData(){
static int ctor=0;
printf("ctor %d\n",ctor);
ctor++;

name = new char[30];
strcpy(name,"");
}

~BaseData(){
static int dtor=0;
printf("dtor %d\n",dtor);
dtor++;

delete[] name;
}

BaseData(const BaseData& p){
static int cctor=0;
printf("copy ctor %d\n",cctor);
cctor++;

name = new char[30];
*this = p;
}

BaseData& operator=(const BaseData& p){
static int assign=0;
printf("assign %d\n",assign);
assign++;

if(this != &p)
{
strcpy(name,p.name);
sensNum = p.sensNum;
}
return *this;
}

LPTSTR name;
BYTE sensNum;
};


This is my main:#include <windows.h>
#include <stdio.h>
#include "base.h"

int main()
{
BaseData b, t1;
BaseData* t2, t3;

strcpy(b.name,"Name");
b.sensNum = 42;
printf("b: %s %d\n",b.name,b.sensNum);

t1 = b;
printf("t1: %s %d\n",t1.name,t1.sensNum);

t2 = new BaseData(b);
printf("t2: %s %d\n",t2->name,t2->sensNum);
delete t2;
/*
t3 = new BaseData; //this statement won't compile
t3 = b;
printf("t3: %s %d\n",t3->name,t3->sensNum);
delete t3;
*/
return 0;
}

The output is:
ctor 0
ctor 1
ctor 2
b: Name 42
assign 0
t1: Name 42
copy ctor 0
assign 1
t2: Name 42
dtor 0
dtor 1
dtor 2
dtor 3

First off why is the dtor called 4 times? t3 is never created so why is it begin destroyed? Second, though I think this is a result of using printfs, why is ctor 2 printed before b: Name 42? Third and most important, the commented out portion doesn't work and I do not understand why. Can someone explain? Finally does this class leak memory and/or what is wrong with it if anything? (I just started having problems in my larger program and I think it has something to do with this class).

[Philip Nicoletti]

The line in your code :


BaseData* t2, t3;


is the same as :


BaseData* t2;
BaseData t3; // not BaseData* t3;

[pim42]

Oh ok... now that you say that I remember. I used to put the * on the variables and not the type and recently changed.

It is amazing how much you can forget when you don't use it for awhile. I now have:

BaseData b, t1, *t2, *t3;

Well that answers my first and second questions, still have the third.

[pim42]

NEVERMIND, all I had to do now is change t3 =b to *t3=b.

you fixed all my problems and I feel stupid for having them. thanks for the help.

[Paul McKenzie]

Originally posted by pim42
Finally does this class leak memoryAre you trying to wrap handling of char data in a class? If so, why not just use std::string?

#include <string>
class BaseData
{
private:
std::string name;

public:
BaseData(){
static int ctor=0;
printf("ctor %d\n",ctor);
ctor++;
}
};

Note that you really do not need a copy ctor, assignment operator, or destructor if you use std::string. I've cut the size of your class down to a fraction of what it was originally, does virtually the same thing as your original code does, and it is maintainable.

Regards,

Paul McKenzie

[pim42]

no this was actually a dumbed down version of a hardware sensor class. I'm interfacing a C dll so I'm using LPTSTR to match the function calls. (You might recall from pervious posts that I am required to use the same data types as the dll interface, thus no std::string).

[Paul McKenzie]

Originally posted by pim42
no this was actually a dumbed down version of a hardware sensor class. I'm interfacing a C dll so I'm using LPTSTR to match the function calls. (You might recall from pervious posts that I am required to use the same data types as the dll interface, thus no std::string). Use vector<TCHAR>, or if the DLL doesn't modify your buffer, std::string::c_str(). Same thing, less headaches.

For example, if your DLL function is prototyped like this:

void func(LPTSTR s);

The way you would call it using a vector is as follows:

vector<TCHAR> vt( 20 ); // or whatever the number of characters
//...
func(&vt[0]);

The std::vector is the gateway to interfacing to 'C' functions. The vector stores its data in contiguous memory.

To specify a char *, int *, long*, whatever *, the way to do it is to create a vector of the type desired, and just specify the address of the first element when calling the function. Therefore, your entire class interface can be simplified to this:

#include <string>
class BaseData
{
private:
std::vector<TCHAR> name;

public:
BaseData() : name(31, 0) {
static int ctor=0;
printf("ctor %d\n",ctor);
ctor++;
}
};

Again, no new, delete, copy constructor, op=, or destructor is necessary. This trick of using the std::vector instead of the "new[] / delete[]" stuff that a lot of code is littered with makes the program less problematic and easier to maintain. Also, if I want to resize the name field, all I have to do is call name.resize(). I don't have to do the "new / copy / delete " coding.

Scott Meyer's book, "Effective STL", has an entire chapter dedicated to interfacing to 'C' functions using the standard containers.

Regards,

Paul McKenzie