Re: pointer arithmetic and std::vector
On Jul 3, 6:47 am, aaragon <alejandro.ara...@gmail.com> wrote:
I have the following problem. Let's say you have three
std::vector objects and you need to access the contiguous
memory as if they were part of a regular array. That is, I
would like to access each vector using pointer arithmetic such
that the beginning of each vector is obtained by an offset or
displacement from the first vector.
The contents of each vector is guaranteed to be contiguous.
However:
The following code works in my computer with GNU g++ v4.3:
#include <vector>
#include <iostream>
using namespace std;
int main() {
typedef std::vector<int> vec;
vec v1(10,1);
double* temp = new double(22.3);
vec v2(20,2);
vec v3(30,3);
[...]
int* add1 = &v1[0];
int* add2 = &v2[0];
int* add3 = &v3[0];
cout<<"printing vector 1 using address"<<endl;
for (int* addc1 = add1; addc1 != add1 + v1.size();)
cout<<" "<<*addc1++;
cout<<endl;
This is guaranteed to work, but...
cout<<"address diference add2-add1 -> "<<add2-add1<<endl;
The results of add2 - add1 are unspecified. (The same would be
true if instead of vector, you were using C style arrays.) If
the system uses linear addressing, it will probably work as long
as there are no intervening reallocations of the arrays, but as
far as the standard is concerned, it is undefined behavior (and
I've used systems where it couldn't be made to work---where the
real difference between two addresses could be larger than a
ptrdiff_t or a size_t).
[...]
So it seems that it works,
On one particular system, in one particular context.
but the question is if this ALWAYS will work, independent of
the value stored in the vectors or it will break at some
point.
Absolutely not. There are some exotic architectures (Intel, for
example) where it won't always work. (Current Windows and Linux
artificially restrict process memory in a way that means that it
probably will work under them, but I've used OS's on Intel 32
bits which didn't, and back in the days of 16 bit Intel, no
system dared restrict process memory to 64KB.)
I found that using pointer arithmetic, the subtraction is of
type ptrdiff_t, and according to the cplusplus.com:
"A subtraction of two pointers is only granted to have a valid
defined value for pointers to elements of the same array (or
for the element just past the last in the array). For other
values, the behavior depends on the system characteristics and
compiler implementation."
From the standard (concerning subtraction between two pointers):
"Unless both pointers point to elements of the same array
object, or one past the last element of the array object, the
behavior is undefined." And also: "If the result [of the
subtraction] does not fit in the space provided [by
std::ptrdiff_t], the behavior is undefined" (although that's not
likely to be a problem for anything other than char*).
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34