Assigning 2D variable sized arrays - c++

Question

I'm trying to store a 2D array of variable length c-strings into a struct so I can transmit and rebuild it over a network socket.
The plan is to have rows and cols, which is in the header of the packet, help me read the variable size lens and arr that come after. I believe I must be syntactically writing the pointers incorrectly or there's some kind of aux pointer I need use when setting them into the struct.
struct STORAGE {
int rows; // hdr
int cols; // hdr
int** lens;
const char*** arr;
}
// code
int rows = 11;
int cols = 2;
int lens[rows][cols];
const char* arr[rows][cols];
// ... fill with strings ...
// ... along with lens ...
STORAGE store;
store.rows = rows;
store.cols = cols;
store.lens = lens;
store.arr = arr;
I get these errors when compiling this code:
error: invalid conversion from int to int** [-fpermissive]
error: cannot convert const char* [11][2] to `const char***' in assignment
I come from mostly a Java background, but I do understand how pointers work and such. The syntax of this one is just a little sideways for someone with my background (mostly write java/c++ and less c). Any suggestions?
Note: the reason why I'm not using more complex types like strings, maps, vectors, etc is that I need to transmit the structure over the network (ie pointers to the heap won't work if they have variable sizes). It must be low-level arrays unless someone can offer a better solution.

Answer 1

It must be low-level arrays unless someone can offer a better solution.
A unidimensional std::vector<int> or std::vector<uint8_t> already provides you with a low-level array allocated contiguously using the std::vector::data() member.
Any further dimensions you need might be determined by sectioning that data properly. For network transmission, you would need to provide the necessary sectioning dimensions up front, and sent the data afterwards.
Something like:
Transmit num_of_dimensions
Transmit dim_size_1, dim_size_2, dim_size_3, ...
Transmit data
Receive num_of_dimensions
Loop Receiving dimension sizes
Receive dim_size_1 * dim_size_2 * dim_size_3 * ... of data
What I'd probably have to handle such situation is a class / struct looking like:
template<typename T>
class MultiDimensional {
size_t num_dimensions_; // If known in advance can be made a template parameter also
std::vector<size_t> dimension_sizes_;
std::vector<T> data_;
public:
const T& indexing_accessor(...) const;
T& indexing_accessor(...);
std::vector<uint8_t> render_transmision_data();
// construct from transmission data
MultiDimensional(std::vector<uint8_t>& transmission_data);
};

Answer 2

Using low-level stuff like arrays won't help you much, it's too complicated already. Also, it can get you in a hell of compatibility problems (like thinking about byte-order).
Unless you have very strict performance constraints, use a solution designed specifically for networking instead: protocol buffers. This is a bit of overkill for your case, but it scales well in case you need to add anything.
To use protocol buffers, you first define "messages" (structures) in a .proto file, then compile them to C++ with Proto Compiler.
You define your message like this (this is a complete .proto file):
syntax = "proto2";
package test;
message Storage {
message Row {
repeated string foo = 1;
}
repeated Row row = 1;
}
There is no direct support for 2D arrays, but an array of arrays will do just fine (repeated means that there can be multiple values in given field, it is basically a vector). You could add fields for array size, if you need quick access to them, but checking the size of repeated fields should suffice in most practical cases.
What you get is a class that have all the fields you need, takes care of memory management, and have a bunch of methods to serialize and deserialize.
The C++ code gets a little longer in places, as you need to use getters and setters, but it should be well offset by the fact that you never need to think about serialization - it happens all by itself.
Example use of this thing in C++ could look like this:
#include "test.pb.h" // Generated from test.proto
using ::test::Storage;
int main() {
Storage s;
Storage::Row* row1 = s.add_row();
row1->add_foo("foo 0,0");
row1->add_foo("foo 0,1");
Storage::Row* row2 = s.add_row();
row2->add_foo("foo 1,0");
row2->add_foo("foo 1,1");
assert(s.row_size() == 2);
assert(s.row(0).foo_size() == 2);
s.PrintDebugString(); // prints to stdout
}
In the result, you get this output (note that this is debug output, not real serialization):
row {
foo: "foo 0,0"
foo: "foo 0,1"
}
row {
foo: "foo 1,0"
foo: "foo 1,1"
}
For completeness: in above example the source files were test.proto and test.cpp, compiled using:
protoc --cpp_out=. test.proto
g++ test.cpp test.pb.cc -o test -lprotobuf