C / C++ / MFC

Re: How to store array in vector in C++

24-Jul-09 7:57

typedef vector<Whatever> WhateverV;

int Store(Whatever const& w, WhateverV vw)
{
vw.push_back(w);
}

«_Superman_»24-Jul-09 17:59

«_Superman_»

24-Jul-09 17:59

Create a vector of unsigned chars - std::vector<unsigned char> vBytes;
To copy the received byte to the end of the vector do this - vBytes.insert(vBytes.end(), size);

If you want to implement some sort of queue where you also consume the data you should use the deque class instead of vector.

«_Superman_»
I love work. It gives me something to do between weekends.

Tab control implementation in MFC document / view application. [modified]

Vaclav_24-Jul-09 5:55

Vaclav_

24-Jul-09 5:55

Which is more appropriate to use in MFC document / view architecture to display (view) the document - CTabCtrl or CCtrlView?
I am looking at the CTabCtrl as a control “overlay” of views. Is that correct? For lack of other words – the document communicates with tab class first and the tab class than communicates with tabs / plain views.
Or would using CCtrlView be simpler?
Any constructive comments as always are appreciated.
Cheers Vaclav

PS I forgot to mention "minor" detail - currently I am using CCtrlView with CTabCtrl variable with some isssues.I need to investigate if CTabCtrl can be used directly as a view anyway.

modified on Friday, July 24, 2009 12:07 PM

safely returning classes from functions... when and when not to construct !

paolosh24-Jul-09 5:04

Re: safely returning classes from functions... when and when not to construct !

24-Jul-09 5:04

Hi all,

Am i right in thinking that foo() is a very SAFE and SLOW way of passing stuff around, whereas bar() which is LESS SAFE but FASTER.

MyClass foo()
{
MyClass x;

// do something with x

return MyClass(x);
}

MyClass* bar()
{
MyClass * x = new MyClass();

// do something with *x

return x;
}

If i call foo() with something like MyClass c = foo(), there will be:-

1 instantiation, 2 copies, and 1 destruction + overhead of "do something with x"

If i call bar() with something like MyClass *b = bar(); delete b, there will be:-

1 construction, 1 destruction + overhead of "do something with x"

So, for internal codey type functions which are protected from the user, it would be quite acceptable to use a bar() type mechanism in order to gain more speed.

However, for functions designed to be used by an external user in a safe way, we should stick to foo().

Paul

josda100024-Jul-09 8:21

josda1000

24-Jul-09 8:21

I believe that both will have the same amount of time. You have no reason to, at the end of foo(), 'return MyClass(x);', because this will cast a MyClass object to MyClass (redundant), which in effect calls the copy constructor for MyClass. Basically, whether you use the stack or the heap, this function would have done the same exact thing if you did not call that copy constructor. And, as long as you delete the object in bar(), it is totally safe, in my opinion. If my thoughts seem incorrect, I'd love to hear about it... I could be wrong of course.

Re: safely returning classes from functions... when and when not to construct !

paolosh24-Jul-09 23:48

Beginner: How to access elements in a Variant array of Variants (8204)

24-Jul-09 23:48

No, you are correct !

After playing around with the code and debugging I found what you said to be true. I am learning on the job, so sorry for the confusion in my original code.

Thanks for your help,

Paul

BeerFizz24-Jul-09 4:19

BeerFizz

24-Jul-09 4:19

Hi,

I have an array of variants, but I'm unsure how to access the individual elements withing this array:

_RecordsetPtr ptrRS;

ptrRS = wr->GetData();	// returns a record set of rows from a table
		
_variant_t vtRows = ptrRS->GetRows(adGetRowsRest);

int vt = vtRows.vt;

str3.Format("vt %d", vt);
MessageBox(str3);		//  displays 8204
			
_variant_t vRow;
vRow = vtRows[0];		// does not compile

Could someone please assist me with a code snippet on how to do this.

Thanks
Phil

Returning large objects from a function without unnecessarily invoking the constructor !

paolosh24-Jul-09 3:31

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 3:31

Hi all, hope you could maybe give me some advice on the following...

Is the following code legal?

MyClass foo()
{
MyClass * p = new MyClass();

// do something to *p here

return *p;
}

void test()
{
foo();
}

void main()
{
test();
}

The above code compiles and works fine. The intention is to create a MyClass instance in foo, and return it without onvoking the constructor on exit. I then want this instance to be available in test. On exit of test i want this instance to be automatically deleted.

It seems to work fine, but when I use the same mechanism in large programs, including classes etc., I am running into some difficulties when the "return *p" executes.

Thanks,
Paul
Wink | ;)

transoft24-Jul-09 3:43

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 3:43

In your

void test()
{
foo();
}

You did not handle "p". This is a memory leak. You should delete p;

void test()
{
  Myclass* p = foo();

do something with "p" then

  delete p;
}

paolosh24-Jul-09 3:51

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 3:51

Thanks for the reply.

I've debugged the presented code step by step and witnessed that the compiler deletes p itself on exit from test() !

However, the presented code is not OOP. When the same mechanism is used in an OOP set-up SOMETIMES I get errors. Perhaps I'm missing something.

--------------------------------------------------------------

Anyway, is there a way to achieve what I want without having to delete p by hand?... I basically want to instantiate an object in foo and then return it to the calling function. I would then like the calling function to auto-delete that instance on exit.

Paul

peterchen24-Jul-09 3:58

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 3:58

paolosh wrote:
I've debugged the presented code step by step and witnessed that the compiler deletes p itself on exit from test() !

It does not.
What happens is this:

new MyClass creates a new MyClass instance on the heap
return *p returns a COPY of that object

That copy is a temporary variable, and will be destroyed. However, the instance allocated on the heap will not be destroyed.

You may want to lear a bit more about C++ pointers, copy constructors and temporary values (it is not an easy topic).

When you understand these things, I would suggest my article about smart pointers[^] as an introduction to a common solution to your original question - "returning large objects from a function".

Don't attribute to stupidity what can be equally well explained by buerocracy.
My latest article | Linkify!| FoldWithUs! | sighist

paolosh24-Jul-09 4:09

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 4:09

So what of the overloaded functions?

in standard C++ you can do something like this...

double x, y, z;

z = x + y;

does x.operator +(y) return a temporary double? which is then destroyed after it's contents is assigned to z??

peterchen24-Jul-09 8:37

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 8:37

Yes, exactly.

With a "double", there is no constructor or destructor, so there is not much to see.

But you can try these things with a class like this you can play around and see the effects:

class MyTest
{
public:

   MyTest() { cout << "Creating MyTest " << this << endl; }
   MyTest(MyTest const & rhs) { cout << "Copy-Construct MyTest " << this << " from " << &rhs << endl; }
   MyTest& operator=(MyTest const & rhs) { cout << "Assign MyTest " << this << " from " << &rhs << endl; }
   ~MyTest() { cout << "Destroying " << this; }
}

Be aware that the effects are not exactly the same on every compiler, since the standard allows some optimizations.

Don't attribute to stupidity what can be equally well explained by buerocracy.
My latest article | Linkify!| FoldWithUs! | sighist

transoft24-Jul-09 5:04

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 5:04

I have a question for you.

I checked following:

p1 = new myclass();

p2 = foo()

p1 is exactly same as p2.

If foo() return a COPY of a POINTER, why the address of the COPY will be same as the original one?

Thanks

peterchen24-Jul-09 5:09

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 5:09

paolosh's original code is more akin to this:

MyClass * p1 = new MyClass;
MyClass temp = *p1;

Don't attribute to stupidity what can be equally well explained by buerocracy.
My latest article | Linkify!| FoldWithUs! | sighist

transoft24-Jul-09 5:27

Re: Returning large objects from a function without unnecessarily invoking the constructor !

24-Jul-09 5:27

When returning a "POINTER", it return POINTER itself or just a copy of the POINTER?

I debug the code. I found out the address of the "return" one is exactly same as the original one (new Myclass()).

Thanks,

peterchen24-Jul-09 8:31