Guaranteed Padding?

Given a class of the form

Code:

---

class DataVector
{
    public:
          DataVector(int i, int j, int k){
              _vals[0] = i;
              _vals[1] = j;
              _vals[2] = k;
          }

          int* data(void){return _vals;}

    private:
          int _vals[3];
}

---

and assuming there is _no_ other data in the class, do the language specs guarantee the following snippet is valid?

Code:

---

std::vector<DataVector> myVec(2);
myVec[0] = DataVector(0,1,2);
myVec[1] = DataVector(3,4,5);

int* dP = myVec[0].data();
std::cout<<dP[0]<<" "<<dP[1]<<" "<<dP[2]<<" "<<dP[3]<<" "<<dP[4]<<<<" " <<dP[5];
//should output 0 1 2 3 4 5

---

The reason I'm implementing the code this way is that I may need to pad the 3 dimensional vector to 16 bytes with an extra element depending on some external factors that are currently out of my control. If there are better ways of doing this, I'm open to suggestions.

Not at all.

Each instance of DataVector is a completely separate instance.

There is no reason for them to be contiguous, nor any reason for one to follow the other in memory.

However, correct me if I'm wrong, std::vectors use a contiguous block of memory and store their own copy of the data. Are you implying that the data itself may be stored non-contiguously but that pointers to the data are stored contiguously?

Also, unless I'm missing something, 34.3 here seems to be referring to a similar case, yes?

OIC, you're making copies of the DataVector when you assign the elements of your vector.

Your DataVector's will be contiguous (as per the link you posted).

The problem remains however that you don't know how much padding there is at the end of each instance of DataVector. Now since your struct contains only one data element (and it's a POD), there doesn't seem to be any need for the compiler to add any padding.

I think practically, the answer is "no padding", but there is no guarantee of that.

Ah ok, you were referring to the data in the class itself. Makes sense.

Quote:

---

Originally Posted by golfinguy4

The reason I'm implementing the code this way is that I may need to pad the 3 dimensional vector to 16 bytes with an extra element depending on some external factors that are currently out of my control. If there are better ways of doing this, I'm open to suggestions.

---

I suggest you add a member function, say print() to the DataVector class. This might do something like;

Code:

---

void DataVector::print(std::ostream &s)
{
    s << _vals[0] << ' ' << _vals[1] << ' ' << _vals[2];
}

---

To print a vector of them, you might do;

Code:

---

for(std::vector<DataVector>::iterator i = myVec.begin(), end = myVec.end(); i != end; ++i)
{
    std::cout << ' ';
    (*i).print(std::cout);
}
std::cout << '\n';

---

This way, the only thing that needs to change when you change your DataVector class is its implementation of print().

No need to worry about padding at all.

Incidentally, it is a bad idea to use underscores as the first character in any identifier in your code, unless you are implementing the standard library for your compiler. The C++ standard reserves such identifiers for use by the implementation, and your code gives undefined behaviour if you use reserved identifiers.