how to generate data and how to pass it over? - c++

Question

let's say that i need to create some buffer or a vector of objects or whatever
and that data needs to be given to an object constructor...
is it common practice to be generate the data in a class function like this
class A
{
void gen()
{
vector<Data*> v;
obj= new Obj(&v);
}
}
...
class Obj
{
private:
vector<Data*> *data;
public:
Obj(vector<Data*> *v)
{
data=v;
}
}
good idea? bad idea?
the background question would be do i use pointers, references... as entry and output of my functions & constructors, when and for what reason...
thanks

Answer 1

In particular, this is a very bad idea:
{
vector<Data*> v;
obj= new Obj(&v); // 1: pass address of v
} // 2: v gets destroyed (obj will hold the address of
// an out-of-scope variable) and application will
// probably crash when it attempts to use it.
do i use pointers, references... as entry and output of my functions & constructors, when and for what reason...
That's a ... broad subject. In general, you should:
use objects directly, when declaring them in a scope (by value).
pass objects by const reference, when the function you pass them in just needs read-only access.
pass objects by non-const reference when the function alters the object
if you need an object outside of the scope you create it in, return by value if possible, otherwise use a pointer (see "avoiding raw pointers" below)
Avoiding raw pointers:
raw pointers (T*) should be:
replaced with std::unique_ptr when only one owner of the pointer will exists (when the pointer is used in one place)
replaced with std::shared_ptr when ownership is shared, there are multiple owners, or when there is no clear owner of the pointer.
replaced with std::vector when you need an arbitrary length array of values
replaced with std::array when you need an array of n values
the only places where you use raw pointers are:
when you are interested in the pointer values themselves (e.g. logging allocated addresses, tracking memory, writing an allocator or object pool, implementing an iterator type)
when you are interacting with legacy or the C library.
In your particular case:
class Obj
{
private:
vector<Data*> data; // store by value
public:
Obj(vector<Data*> v) // pass by value (creates a copy of the data)
: data{ std::move(v) } // move passed value into internal member
{
}
};
class A
{
Obj gen() // return obj by value
{
vector<Data*> v; // allocate by value
Obj obj{ std::move(v) }; // move v into obj
return obj; // return by value
}
};