### mohmahkho's blog

By mohmahkho, 20 months ago,

Hi! I hope you are doing well.

If you are in love(!) with vectors and you use them a lot, you probably know that defining a multidimensional vector is just a pain in the neck! For example if you are trying to define a 3 dimensional vector with (n, m, k) as dimensions you have to write it like this :

vector<vector<vector<int>>> a(n, vector<vector<int>>(m, vector<int>(k)));


Then you change your mind and realize that your data will not fit in an int. You decide to change it to long long.

vector<vector<vector<long long>>> a(n, vector<vector<int>>(m, vector<int>(k)));


[HITS COMPILE BUTTON] Oops! won't compile (G++ really get's mad at you). Go on and change inner vectors as well.

vector<vector<vector<long long>>> a(n, vector<vector<long long>>(m, vector<long long>(k)));


So if you want a 100 dimensional vector of long longs, you literally have to say it 100 times to the compiler that you want your data to be long long.
Well what's the solution?

### N dimensional vector using template meta programming

So yes, there is this thing called template meta programming which I'm not going to discuss here. But you can do cool things with it! One of the cool things is just N dimensional vector (basically D dimensional!). Here's the code:

template<int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
static_assert(D >= 1, "Vector dimension must be greater than zero!");
template<typename... Args>
Vec(int n = 0, Args... args) : vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {
}
};
template<typename T>
struct Vec<1, T> : public vector<T> {
Vec(int n = 0, const T& val = T()) : vector<T>(n, val) {
}
};


This is essentially publicly inheriting from vector<vector<vector< ... vector<T> ... >>> in which vector appears D times!
It has a constructor which takes dimensions in order and if you want to initialize your multidimensional vector with some value you can pass that value to the constructor as the last argument otherwise it will be initialized with zero (or if it's a class it will be initialized using default constructor). If you provide less than D numbers to the constructor, following dimensions will have length equal to zero.
A few examples :

Vec<2, int> a(10, 50); // int a[10][50] initialized with zero
Vec<3, double> b(n, m, k, 3.14); // double b[n][m][k] initialized with 3.14
Vec<3, long long> c(5, 5); // the third dimension has no value yet
c[0][0].push_back(100); // now c[0][0][0] has a value (100) but others don't
Vec<4, int> d(10, 10);
d[2][3].push_back(Vec<1, int>(100, 12345)); // now d[2][3][0] is a vector with 100 values of 12345
Vec<1, string> e; // just blank vector of strings


Based on C++11 (or above) standard this code will compile.
Template arguments must be compile time constants, for example Vec<n, int> in which n is the user input, won't compile, which makes a lot of sense.

• +417

 » 20 months ago, # |   +20 I loved your effort. It is awesome.
 » 20 months ago, # | ← Rev. 2 →   -10 Nice use of templates, added to my library. Keep doing such experiments
•  » » 20 months ago, # ^ | ← Rev. 2 →   +3 What the heck, I don't know why only I am getting downvotes?? Did I comment something wrong?
 » 20 months ago, # |   +12 Salute you,brother. You saved my time.
 » 20 months ago, # |   +16 Awesome, you just discovered arrays!Just kidding, well done!
 » 20 months ago, # |   +36 Fuck array. All my homies use vector.
 » 20 months ago, # |   +2 Bookmarked!!
 » 20 months ago, # |   -33 مهبل كس مهبل مهبل ديك لول موظر مص الحمار الحمار لعق الشرج
•  » » 20 months ago, # ^ |   0 Wow! You've written a poem! What's behind this text?
•  » » » 20 months ago, # ^ |   +18 P=NP proof
 » 20 months ago, # |   0 really nice , thank you.
 » 20 months ago, # |   +58 I think I've got it more elegant: template auto create(size_t n, Args&&... args) { if constexpr(sizeof...(args) == 1) return vector(n, args...); else return vector(n, create(args...)); } It requires C++17. Usage: int n, m; cin >> n >> m; auto dp = create(n, m, 0LL); That creates a vector> of size n by m filled with value 0. As you see, the code is shorter and it doesn't need constant sizes. Thanks kwazar for showing this neat trick. Working example: https://codeforces.com/contest/1336/submission/77118622
•  » » 20 months ago, # ^ |   +1 That's interesting and the good part I think is that you don't inherit from std::vector.However I like to be explicit about type of the container. When I write Vec<3, int> I know it's a 3 dimensional vector of ints, and if I don't care about the third dimensions size, I just don't write it there (Vec<3, int> a(n, m) and the third dimension is yet to be decided).Also I think there is a misunderstanding about what I said in the last line. I just said the number of dimensions must be compile time constant not the dimension size and something like Vec<2, long long> v(n, m, 0) is completely legit in my code.
•  » » » 20 months ago, # ^ |   0 The last argument explicitly tells the compiler what type it should be. auto dp = create(n, m, int(42)) is even more specific. If that isn't explicit enough, you can look at this: template auto create(size_t n, Args&&... args) { if constexpr(sizeof...(args) == 1) return vector(n, args...); else return vector(n, create(args...)); } auto dp = create(n, m, 42.69); I find create(n, m, 0, 0) more readable and less error-prone than Vec<3, int>(n, m), though that might be my personal preference.
•  » » 20 months ago, # ^ |   +13 tnowak How to pass this to function?
•  » » » 20 months ago, # ^ |   0 The shortest way would be: int f(auto &x) { return x[0][0]; } Usage: cout << f(dp) << '\n';
•  » » » » 20 months ago, # ^ |   0 Getting 'auto' not allowed in function prototype
•  » » » » » 19 months ago, # ^ |   0 https://codeforces.com/contest/1336/submission/77287957 For me it is working. Alternatively use this code: template int f(T &x) { return x[0][0]; } 
 » 19 months ago, # |   +1 That kind of template is really useful. I have been experimenting in-contest with a similar one. One feature I added to my template that I liked, is to override the operator() so you can query and assign using syntax:dp(i, j, k) instead of the usual dp[i][j][k], for example this 76759577
•  » » 19 months ago, # ^ |   +3 Yeah, I was once thinking about it, it's probably easier to write, however you may confuse it with normal function call. It would have been way better to be able to write it like dp[i, j, k] but operator[] has to take only one parameter.
 » 19 months ago, # | ← Rev. 2 →   +16 This can also be done using the template argument deduction feature of C++17. This produces a 100x200x300 3D array. vector arr3D(100, vector(200, vector(300, 123))); 
•  » » 19 months ago, # ^ | ← Rev. 2 →   +3 Two issues:1- C++17 (some OJs don't support it even though they should IMO)2- You still have to write "vector" for each dimension.BTW it's a matter of taste I guess.
 » 19 months ago, # |   +2 Thanks for sharing this trick! Unfortunately, clang doesn't accept this code, which is problematic for those who use clang-powered auto-completion like me :(
 » 19 months ago, # |   0 Btw, if you're after something sufficiently practical and easy to remember rather than fancy template metaprogramming, defining your own derived classes vec1D, vec2D etc also works. It's not like you're ever going to use a 5 times nested vector, it will have some tiny dimensions and the memory access overhead will be crazy.
 » 18 months ago, # |   0 I want to initialize Vec<1, T> with initializer list like vector{}. Does anyone have a method to do this?
•  » » 18 months ago, # ^ | ← Rev. 2 →   +11 The easiest way to tweak the code to support what you wanted (that came to my mind) : template struct Vec : public vector> { static_assert(D >= 1, "Vector dimension must be greater than zero!"); template Vec(U n = U(), Args... args) : vector>(n, Vec(args...)) { } }; template struct Vec<1, T> : public vector { template Vec(Args... args) : vector(args...) { } }; then you will be able to initialize it with another vector like this: vector a {2, 7, 1, 8}; Vec<1, int> b(a); Vec<1, int> c(a.begin() + 1, a.end()); Vec<1, int> d(initializer_list {3, 1, 4, 1, 5, 9}); Note that it is still possible to use it the old way.
 » 8 months ago, # | ← Rev. 2 →   -8 Simply awesome !