How is an object stored in memory?

1) what is the order of memeber data that gets stored in memory? by the line order?

-The compiler is free to do as it pleases here.

2) will the offset for each member data always be the same between objects?
- Yes, as far as I know this will be the case.

3) in the case of a vector, since each abc object might have a different size
vector c, what is stored in the abc object?
if it is the address to the vector head, does that mean each abc object will always have the same size in memory? (not counting the memory used by the vector)

r is the entire vector stored "inline" within the abc object? so in this case, the offset for each member data after the vector will be different depending on how big the vector is?

I don't fully understand you. However this might help: a vector is a template class, so if the template type changes (vector<int> vs vector <someclass>) the size and offsets of the vector will not be similar (they are really two different classes!, think of them as class vector1 and class vector2)

4) Assuming that the offset is the same, how would I determine the type of data that is at the offsect? I'm using void * to do the arithmetic but found that I've no efficient way of casting to the right data type when I actually compare.

I think you are getting into trouble here. However, look at run time type info (rtti) and see if that is what you need.

Thanks!

Let me ******** my question...when I define vector<int> c;
what is stored in the oject? is it the address of the start of the vector?
so the variable immediately after the vector is always 4bytes away from the variable preceding the vector?

The object has the data and functions associated with the vector class (created from the template). This is not a pointer, its a class variable. If you took the raw address of the variable, at some offset would be the "array" or pointer to the actual data, but the offset will vary from compiler to compiler and (possibly) across different vector types. If you are looking for the raw data, however, you can get to that via member functions / data members; or simply use vectorVar[x] notation like an array. The bottom line is that the vector class has a LOT of stuff in it, its not just a simple class wrapper around a pointer or anything remotely like that.

I just didn't know if variable length ojects (string, vectors, etc) will affect the offset of other member data in any way

It *should* not, as those are actually pointers. so the memory layout would be something like

member data
member data
member data
-- *** pointer to dynamic memory for the data you seek, same place, same offset
method
method
more stuff

So it *should* be safe and all, but is risky, less than portable (might work on one compiler and not another) and not exactly the "right way to go about it" unless you have a very compelling reason (noticable performance increase, only way to link in some legacy code, or the like).

I just didn't know if variable length ojects (string, vectors, etc) will affect the offset of other member data in any way

It *should* not, as those are actually pointers. so the memory layout would be something like

member data
member data
member data
-- *** pointer to dynamic memory for the data you seek, same place, same offset
method
method
more stuff

So it *should* be safe and all, but is risky, less than portable (might work on one compiler and not another) and not exactly the "right way to go about it" unless you have a very compelling reason (noticable performance increase, only way to link in some legacy code, or the like).

The number of elemenets of a container, say vector or string, has absolutely no signifcance here. The container object's size (i.e., what you get from a sizeof(vector<X>) expression) is fixed, and determined at compile time. By contrast, the number of elements is determined at runtime and may change. It's always detached from the memory of the container itself. That is, the elenents of a string vector etc. are accessed by a pointer, so whether a string object has 10 chars or 10 million chars doesn't really matter -- the string object itself will always have the same binary layout.

One more thing: I think I lost your at some point, so you can you please rephrase your question and focus on the offset issue itself? More specifically, what are _val and _base exactly in the following function?
loadCaseGenericLTLongDouble(long double * _val, LoadCase * _base)

Are they members of the same object?

Yes, members of a same object.
where _val is the location of the value I'm interested in within the ojbect, and _base is the start of the object.
By calculating the offset, I can know which value within the LoadCase object i'm interested in comparing.

when you talked about padding, is the padding the same for every object or would each object have a different padding?

Here's the situation:
I've got a vector of LoadCase objects. Each LoadCase consists of many data members (nested structs, strings, vectors, etc...).
So depending on what the user wants, I want to be able to sort the vector of LoadCase objects based on a certain field of data in the load case objects.

I've been brute forcing it by writing a specific lessThan fuction for each value in the LoadCase object. This is fine for a few values but if I want to allow sorting based on every value, I'm looking at over 50 specific lessThan functions.

Instead, I thought of using offsets.

sort(sf1.loadCases.begin(),
sf1.loadCases.end(),
loadCaseGenericLTLongDouble
(
&sf1.loadCases[0].structA.structB.valueX,
&sf1.loadCases[0]
)
);

class loadCaseGenericLTLongDouble
{
public:
loadCaseGenericLTLongDouble(long double * _val, LoadCase * _base)
{
offset = (char *)_val - (char *)_base;
};
bool operator()(LoadCase & itemA, LoadCase & itemB )
{
void * A = &itemA;
void * B = &itemB;

//**********************
A = (char*)A + offset;
B = (char*)B + offset;
//**********************

long double Aprime = *((long double *)A);
long double Bprime = *((long double *)B);
if(Aprime<Bprime)
return true;
else
return false;
}
private:
int offset;
};

does this make sense?

I had already looked at pointers to data members. I did not see how that would help in my goal of writing a generic less than function. what would go in this function?
bool operator()(LoadCase & itemA, LoadCase & itemB ){}

in my code, all the nubmers are long double so I guess padding, if any should be the same. So far, I've sorted based on six different values withing the object and it seems to be working fine.

If using offset is not the right/safe way, how would one write a predicate that allows flexibility? a series of if/then, switch, flag seems inefficient.

Ok, I'm giving pointer to member data a try.
However I'm running into problems with nested struct data.
my class has the following nested structs.

class someobj{

struct Load
{
long double LV,LS,LA,PM,YM,RM;
}

struct partXDATA{
Load compTotal_PwrOn;
Load compTotal_PwrOff;
long double dragExternal,skinFriction;
} partX;

struct parZDATA
{
Load PwrOnAirload_LRP;
Load PwrOnAirload_WLE;
Load PwrOnInertia_LRP;
Load PwrOnTotal_LRP;
} partZ;

}

and here's my comparison

class genericLTLongDouble
{
public:
genericLTLongDouble(long double LoadCase::*_val)
{
this->pmld = _val;
};
private:
long double LoadCase::*pmld;
};

http://www.informit.com/guides/content.asp?g=cplusplus&seqNum=142&rl=1
from the examples, you have:

int A::*pmi = &A::num;

I tried &someobj:: partX.compTotal_PwrOn.LA but it didn't like anything beyone partX.

does this not work for more then one level of variables?

I would certainly use function pointers. Below is just an example how you can use class member function pointers to choose the right member method. The code will return the Example object with a minimum value of b and than c. This can be enhanced and modified to hopefully suite your needs.

enum whichone {ACMP, BCMP, CCMP }
class Example;
int (Example::*fptr)();
List* ExamplesList ;
Class Example {
private:
int a;
int b;
int c;
public:
Example(int, int, int);
int GetaVal() { return a;}
int GetbVal() { return b;}
int GetcVal() { return c;}

};
Example::Example(int aa, int ab, int ac)
{
a = aa;
b = ab;
c = ac;
ExamplesList->Add(this); //add this object to a list
}

void main()
{
Example* pnewExampleObject;
ExamplesList = new List();
int i;
//let'create 10 Example objects
for ( i=0; i < 10; ++i)
pnewExampleObject = new Example(i, i+1, i+2);
//now find the Example object with a minimum value of b
whichone val = BCMP;

pnewExampleObject = GetExampleobjectByMinVal(val);
//now find the Example object with a minimum value of c
val = CCMP;

pnewExampleObject = GetExampleobjectByMinVal(val); //get Example object with minimum c

//delete Example objects
for (int i=0; i < 10; ++i)
delete (Example*)ExamplesList->Items[i];
delete ExamplesList; //delete the list object

}
void InitMemberPointers(whichone val)
{

switch (val) {
case ACMP:
fptr = &Example::GetaVal;
break;
case BCMP:
fptr = &Example::GetbVal;
break;
case CCMP:
fptr = &Example::GetcVal;
break;
}
}

Example* GetExampleobjectByMinVal(whichone val)
{
Example* ex;
int index = 0;
int minval;
ex = (Example*)ExamplesList->Items[0];
InitMemberPointers(val);
minval = (ex->*fptr)(); //call member function through a member pointer
for (int i=1; i<10; ++i) {
ex = (Example*)ExamplesList->Items[i];
if ((ex->*fptr)() < minval) {
minval = (ex->*fptr)();
index = i;
}
}
return (Example*)ExamplesList->Items[index];
}

Hope some of this will hepl you

Hi
I' not saying that my approach (attempt) is the best. I just think it's worth looking into. Also private members are accessed through the class member methods and not via pointers so encapsulation is preserved.