Design of C++ dynamic arrays - arrays

Question

I am in the process of designing some classes for dynamic arrays (something like a std::vector). The reason I don't want to use std::vector is because my C++ programs are often used as a library called from C/C++/Fortran/Delphi and therefore takes arrays input as a pointer. For security reasons, a std::vector can't steal a pointer at construction time. My Array1D can work as a std::vector but can also be constructed with a pointer. Unfortunately Visual Studio 2013 seems to be worried about my design. Before presenting the problem, I need to explain this design.
Here is the layout of my class
template <typename T>
class Array1D {
private:
T* data_;
T* size_; // No stored as an int for optimisation purposes
bool owner_;
public:
Array1D(int n) {
data_ = new T[n];
size_ = data_ + n;
owner_ = true;
}
Array1D(T* data, int n) {
data_ = data;
size_ = data + n;
owner_ = false;
}
...
};
Most of the time, it works as a std::vector and owner_ is set to true. One can also construct an Array1D from a pointer, and this time owner_ is set to false. In this case, some operations such as resizing are not allowed (through an assert). Copy constructor and assignment for the array A are designed as:
Array1D(const Array1D& B) : Deep copy of B into A. After construction, A owns its memory.
Array1D(Array1D&& B) : Move operation in all cases. After construction, the ownership status of A is the same as B.
operator=(const Array1D& B) : Deep copy of B into A. If A does not owns its memory, an assert is there to check that A and B have the same size. The assignment does not change the ownership status of A.
operator=(Array1D&& B) : Move operation if A and B owns their memory. Otherwise, we do a deep copy, and the size are checked with an assert if A does not own its memory. The assignment does not change the ownership status of A.
I have applied the same idea to my 2 dimensional array whose elements are stored in row-major order
template <typename T>
class Array2D {
private:
T* data_;
T* size_[2];
bool owner_;
public:
Array2D(int n, int p) {
data_ = new T[n];
size_[0] = data_ + n;
size_[1] = data_ + p;
owner_ = true;
}
Array1D(T* data, int n, int p) {
data_ = data;
size_[0] = data + n;
size_[1] = data + p;
owner_ = false;
}
...
Array1D<T> operator()(int i) {
Array1D<T> row(data_ + i * nb_columns(), nb_columns());
return row;
}
...
int nb_columns() const {
return static_cast<int>(size_[1] - data_);
}
};
The Array1D returned by operator()(int i) does not own its memory and contains a pointer to the ith-row owned by the Array2D object. Is is useful in the following kind of code
sort(Array1D<T>& A); // A function that sorts array in place
Array2D<double> matrix(5, 100); // Construct an array of 5 rows and 100 columns
... // Fill the array
sort(matrix(3)) // Sort the 4th row
Those "temporary views" for rows of an 2 dimensional arrays are quite useful but I prefer to limit them to temporary objects to limit aliasing.
Unfortunately, using Visual Studio 2013, I get the following warning from the IDE for the line sort(matrix(3)): "Options for binding r-value to l-value reference is non-standard Microsoft C++ extension". I understand that matrix(3) is an object that lives temporarly and modifying it through a sort looks strange. But, as it is a "view", modifying it modifies the memory owned by matrix and is useful.
So my questions are the following:
Is what I am doing valid C++? (modifying a temporary value)
Is there a flaw in this design?
PS: The full code is available on Github.

Answer 1

Is what I am doing valid C++? (modifying a temporary value)
It's not. Non-const lvalue references cannot bind to temporary objects:
http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/
Is there a flaw in this design?
You are modifying the contents that are wrapped in an object. Since you need to have an lvalue, it would simply be fixed by having an intermediate variable:
auto m_temp_lvalue = matrix(3); // get the 4th row
sort(m_temp_lvalue); // sort the 4th row
I hope it helps.