pointer in a class

[mickey]

Hello,
I'm wondering when is necessary/better declare a pointer to an object in a class or a pointer to a vector in a class

class A {
  public:
   vector<flaoat> fvec;
   //or
  vector<float>* fpvec;
  A() {  
      fvec.resize(1000);
      //or
      fpvec = new vector<float>(1000);
  }
};

class A {
  public:
   vector<flaoat> fvec;
   //or
  vector<float>* fpvec;
  A() {  
      fvec.resize(1000);
      //or
      fpvec = new vector<float>(1000);
  }
};

To copy to clipboard, switch view to plain text mode 

What's the thing that lead me to opt one or other?
THe same question if I had a Person p[10]; in the class. Should be better take a pointer to an array of person? How to choice?

thanks

[wysota]

I'm wondering when is necessary/better declare a pointer to an object in a class or a pointer to a vector in a class

The only reasons to declare a pointer instead of an object I see are:
1. The object pointed by the pointer is not owned by the containing object or the instance is shared among more than one containing object.
2. One wants to only forward declare a class in the header file to speed up compilation of dependent objects and slow down initialization of objects.
3. The platform the application is running on has limitations on the stack size and as much data as possible is pushed onto the heap.

Apart from those three situations I see no reason to use pointers instead of objects.

[Shadowfiend]

Although if you do decide not to use a pointer, it might be a good idea to give the vector its initial size in the initialization list:

A() : fvec(1000) {}

A() : fvec(1000) {}

To copy to clipboard, switch view to plain text mode 

[wysota]

Oh, I just thought of another reason to use a pointer instead of a full object - when the use of the object is optional and the full object is allocated only when needed - then you'll need a pointer. On the other hand it doesn't make much sense to do that with a vector because it already lazy allocates it data on the heap, so both conditions are fulfilled with using a vector object instead of vector pointer. The difference in memory footprint will be minimal (unless you resize the vector when constructing it - then there is no lazy allocation there).

[mickey]

Is there any change to use forward declaration with vector, like this:

class vector; // ?
 
class A {
    vector<float>* fvec;
.......................
};

class vector; // ?

class A {
    vector<float>* fvec;
.......................
};

To copy to clipboard, switch view to plain text mode 

[wysota]

Your code that depends on class A will compile faster as it will not have to parse vector's header file each time A's header is included. The application will run a bit slower though, as it'll have to allocate the vector at some point.

[mickey]

Your code that depends on class A will compile faster as it will not have to parse vector's header file each time A's header is included.

but I asked how write it (this above doens't compile)

The application will run a bit slower though, as it'll have to allocate the vector at some point.

I guess the cause is around the allocation on the heap...

[Shadowfiend]

I think the forward declaration has to look something like:

template <class T> class vector;

template <class T> class vector;

To copy to clipboard, switch view to plain text mode 

[wysota]

I'd say it should be "class vector<float>;". I don't see a reason to use a pointer to a vector in this situation, though... It's just asking for trouble and a necessity to write more code.

[mickey]

I'd say it should be "class vector<float>;". I don't see a reason to use a pointer to a vector in this situation, though... It's just asking for trouble and a necessity to write more code.

class vector<float>;
 
class Shape {
	const std::vector<float>* _sides;

class vector<float>;

class Shape {
	const std::vector<float>* _sides;

To copy to clipboard, switch view to plain text mode 

It doesn't compile; compile gets many error on the first line (like as I missed the ";").
I know It's unuseful, but I'd like compile it for study....
thanks.

[Shadowfiend]

Probably because you didn't put it in a namespace. Try:

namespace std { class vector<float>; }

namespace std { class vector<float>; }

To copy to clipboard, switch view to plain text mode 

or:

namespace std { template <class T> vector; }

namespace std { template <class T> vector; }

To copy to clipboard, switch view to plain text mode 

[mickey]

nothing to do

[wysota]

IMHO the pointer shouldn't be const.

[mickey]

IMHO the pointer shouldn't be const.

nothing to do again....

[wysota]

What do you mean by "nothing to do"?

[mickey]

What do you mean by "nothing to do"?

Sorry, my english is not correct.....It means that compiler gets the same errors (a lot) on the line "class vector<float>;" (I took off "const" as you suggested) . Of course, if I include vector.h, there aren't problems...I don't understand how to do this forward declaration

[Shadowfiend]

Sorry, I made a mistake in my template declaration. Try:

namespace std { template <class T> class vector; }

namespace std { template <class T> class vector; }

To copy to clipboard, switch view to plain text mode 

That compiles fine on my computer.

[mickey]

Sorry, I made a mistake in my template declaration. Try:

namespace std { template <class T> class vector; }

namespace std { template <class T> class vector; }

To copy to clipboard, switch view to plain text mode 

That compiles fine on my computer.

Maybe it can be the solution; but then, my problem is in a other place; try to compile this ,please (It doens't compile on .net2005)

//main.cpp
#include <iostream>
#include "forward.h"
#include <vector>
using namespace std;
 
int main (int argc, char argv[]) {
 
	Forward f;	
	vector<float>* fvec = new vector<float>; //EDIT <----------------------------
 
	return EXIT_SUCCESS;
}
//forward.h
#ifndef FORWARD_H
#define FORWARD_H
 
namespace std { template <class T> class vector; } 
// #include <vector> // with only this, all compiles
 
class Forward {
	std::vector<float>* _vec;
public:
	Forward();
	~Forward();
};
 
#endif FORWARD_H
 
//forward.cpp
#include "forward.h"
#include <vector>
using namespace std;
 
Forward::Forward() {
 
	_vec = new vector<float>;
}
Forward::~Forward() {}

//main.cpp
#include <iostream>
#include "forward.h"
#include <vector>
using namespace std;

int main (int argc, char argv[]) {

	Forward f;	
	vector<float>* fvec = new vector<float>; //EDIT <----------------------------

	return EXIT_SUCCESS;
}
//forward.h
#ifndef FORWARD_H
#define FORWARD_H

namespace std { template <class T> class vector; } 
// #include <vector> // with only this, all compiles

class Forward {
	std::vector<float>* _vec;
public:
	Forward();
	~Forward();
};

#endif FORWARD_H

//forward.cpp
#include "forward.h"
#include <vector>
using namespace std;

Forward::Forward() {

	_vec = new vector<float>;
}
Forward::~Forward() {}

To copy to clipboard, switch view to plain text mode 

[Shadowfiend]

Ah, that's right. std::vector takes an std::allocator as its second parameter. Well that just gets nasty...

Here's a place where this same issue is discussed: http://objectmix.com/c/251244-forwar...compliant.html

Looks like it's possible, but the advantage is negligible and there is not necessarily a guarantee that it will work.

[mickey]

Sorry, I did a mistake; what I want to show is that the code doens't still work; see the code I correct it....what I say is that, with your solution, if I put #define <vector> in such file that include even "forward.h", the compiler gets errors; does anyone know how to correct the last code above ,please?