Const object arrays and const object array pointer array?

MyObject(x,y){x = x; y=y;}

Quote:

The lists are static and should not change. Is the correct format? const MyObject* const List1[]

Quote:

ListList is already defined

extern const MyObject** const ListList[];

Quote:

cannot convert from 'MyObject *const [3]' to 'const MyObject **const '

const MyObject* const * const ListList[] 

typedef std::vector<MyObject> ObjectArray;typedef std::vector<ObjectArray> ObjectArrayArray;

ObjectArray objectArray;objectArray+= MyObject(5,6),MyObject(5,6),MyObject(5,6);

Quote:

Original post by stevenmarky MyObject(x,y){x = x; y=y;} This looks really scary, does this actually work?

MyObject(int x, int y) : x(x), y(y) {}

Quote:

Original post by stevenmarky MyObject(x,y){x = x; y=y;} This looks really scary, does this actually work?

Quote:

Quote: The lists are static and should not change. Is the correct format? const MyObject* const List1[] I don't think you need MyObject* there, wouldn't MyObject suffice?

Quote:

Quote: ListList is already defined This is because your ListList is defined inside the header, header inclusion guards won't protect against that. This error is caused because the one definition rule is not being obeyed. To fix it, define ListList in a cpp file instead, and in your header: extern const MyObject** const ListList[];

Quote:

Quote: cannot convert from 'MyObject *const [3]' to 'const MyObject **const ' To fix this your second array type would have to be: const MyObject* const * const ListList[] Read in English, this is an array of constant pointers to constant pointers to constant MyObjects...

Quote:

This isn't very nice. You could use typedefs to make it more readable or you could use a collection class instead of doing pointer magic, or both: typedef std::vector<MyObject> ObjectArray;typedef std::vector<ObjectArray> ObjectArrayArray; You could populate these using a variety of methods. You could just use push_back on the vector, or use something like boost::assign to make it easier: ObjectArray objectArray;objectArray+= MyObject(5,6),MyObject(5,6),MyObject(5,6);

Quote:

Another solution would be to make a 2D array. This would only work if each of your sublists are the same length.

Quote:

Original post by alvaro It is very odd that you would need an array of pointers and then have to use new for each object, unless you need polymorphism. An array of objects should work just fine, has simpler syntax, is more cache friendly and avoids one unnecessary level of indirection.

Quote:

Original post by Athos Hi there this is a bit weird but for the current situation preferred way to store data. I need to define and save some static data in my headerfile. Iv got my object struct MyObject{int x;int y;MyObject(x,y){x = x; y=y;}} I need 2...X lists of this object type. The lists are static and should not change. Is the correct format? const MyObject* const List1[] ={ new MyObject(5,6), new MyObject(5,6), new MyObject(5,6), 0} And Lastly i need an array with pointers to allt lists i have already created( IF there is a better solution i am happy to try it out ) const MyObject** const ListList[] = {List1,List2,..} Main problems I encounter depending on how I write is either "ListList is already defined" although I already use #ifndef "DATA_H" #define "DATA_H" and #endif in the datafile. main.cpp and anotherobject.cpp includes data.h file. The other problem i encounter is cannot convert from 'MyObject *const [3]' to 'const MyObject **const ' Any suggestions or alternate solutions are welcome. The code is not really performance dependent but reading writing from disk and or database is not preferred. ~Athos

#include <iostream>#include <boost/array.hpp>#include <vector>struct Object{    int x;    int y;    Object(int x, int y)        :x(x),y(y)    {    }};Object objects1[10] ={   Object(1,2),   Object(2,2),   Object(3,1),   Object(4,0),   Object(2,-5),   Object(7,0),   Object(0,1),   Object(18,5),   Object(6,10),   Object(1024,-1)};boost::array<std::vector<Object>,3 > objects2 ={    std::vector<Object>(&objects[0], &objects[3]),    std::vector<Object>(&objects[4], &objects[6]),    std::vector<Object>(&objects[6], &objects[9])};int main(int argc, char** argv){    return 0;}

Quote:

Original post by Athos If you do not know the size of the object array. How would you determine how many objects the array contains? ( Kinda invalid point since its static and i should always know the exact size of the array before hand but just for the sake of argument )

Quote:

Original post by johnstanp We use twice the memory needed for storing the objects.

Quote:

Original post by Zahlman Quote: Original post by johnstanp We use twice the memory needed for storing the objects. Really? Approach 1: Actual array of objects for each 'row', array of pointers to rows for the main list. Cost: 1 object per object, 1 pointer per row. Approach 2: Single array of all objects, array of ints storing the starting index of each row. Cost: 1 object per object, 1 int per row. On typical 32-bit systems, ints are the same size as pointers.

Object objects1[10] ={   Object(1,2),   Object(2,2),   Object(3,1),   Object(4,0),   Object(2,-5),   Object(7,0),   Object(0,1),   Object(18,5),   Object(6,10),   Object(1024,-1)};boost::array<std::vector<Object>,3 > objects2 ={    std::vector<Object>(&objects[0], &objects[3]),    std::vector<Object>(&objects[4], &objects[6]),    std::vector<Object>(&objects[6], &objects[9])};