C++ Making a 2D boolean matrix

What you are trying to do would be the same as this:

std::vector<unsigned int> v1 { 1, 2, 3, 4, 5 }; std::vector<unsigned int> v2 { 6, 7, 8, 9 }; bool mat[v1.size()][v2.size()] = false; 

This is how the compiler will interpret it without the temporaries and this is invalid. When you declare an array of any type its size has to be known at compile time.

bool mat[2][3] = false; // still invalid bool mat[2][3] = { false }; // Okay const int x = 5; const int y = 7; bool mat[x][y] = false; // invalid bool mat[x][y] = { false }; // okay // Even this is invalid std::vector<int> v1{ 1, 2, 3 }; std::vector<int> v2{ 4, 5, 6, 7 }; const std::size_t x1 = v1.size(); const std::size_t y1 = v2.size(); bool mat2[x1][y1] = { false }; // Still won't compile. 

Value to declare an array must be a constant expression.

Instead of making an array as you have tried to do, you could make a class template that will construct a matrix like object for you. Here is what I have come up with, now the overall design or pattern of this template will fit your condition but the actual implementation to generate the internal matrix will depend on your data and what you intend.

#include <vector> #include <iostream> #include <conio.h> template <class T, class U> class Matrix { private: std::vector<T> m_lines; std::vector<T> m_cols; std::vector<U> m_mat; std::size_t m_size; std::size_t m_lineCount; std::size_t m_colsCount; public: Matrix() {}; Matrix( const std::vector<T>& lines, const std::vector<T>& cols ) : m_lines(lines), m_cols(cols), m_lineCount( lines.size() ), m_colsCount( cols.size() ) { addVectors( lines, cols ); } void addVectors( const std::vector<T>& v1, const std::vector<T>& v2 ) { m_lines = v1; m_cols = v2; m_lineCount = m_lines.size(); m_colsCount = m_cols.size(); for ( unsigned int i = 0; i < m_lineCount; ++i ) { for ( unsigned int j = 0; j < m_colsCount); j++ ) { // This will depend on your implementation and how you // construct this matrix based off of your existing containers m_mat.push_back(m_lines[i] & m_cols[j]); } } m_size = m_mat.size(); } std::size_t size() const { return m_size; } std::size_t sizeRows() const { return m_lineCount; } std::size_t sizelColumns() const { return m_colsCount; } std::vector<U>& getMatrix() const { return m_mat; } std::vector<T>& getLines() const { return m_lines; } std::vector<T>& getColumns() const { return m_columns; } bool operator[]( std::size_t idx ) { return m_mat[idx]; } const bool& operator[]( std::size_t idx ) const { return m_mat[idx]; } }; int main() { std::vector<unsigned> v1{ 1, 0, 1, 1, 0 }; std::vector<unsigned> v2{ 0, 1, 1, 1, 0 }; Matrix<unsigned, bool> mat1( v1, v2 ); int line = 0; for ( unsigned u = 0; u < mat1.size(); ++u ) { line++; std::cout << mat1[u] << " "; if ( line == mat1.sizeRows() ) { std::cout << "\n"; line = 0; } } std::cout << "\nPress any key to quit.\n" << std::endl; _getch(); return 0; } 

Output

0 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 

With this template class you can create a matrix of any type U by passing in two vectors for type T. Now how you construct the matrix will be implementation dependent. But this class is reusable for different types.

You could have two vectors of type doubles, and construct a matrix of unsigned chars, or you could have two vectors of user defined class or struct types and generate a matrix of unsigned values. This may help you out in many situations.

Note: - This does generate a compiler warning, no errors though and it prints and displays properly, but the compiler warning generated by MSVS 2015 is warning C4800: unsigned int: forcing value to bool true or false (performance warning)

This is generated for I am doing a bit wise & operation on to unsigned values; but that is why I set my initial vectors to be passed to this class template's constructor to have all 1s & 0s as this is meant for demonstration only.

EDIT - I made an edit to the class because I noticed I had a default constructor and had no way to add vectors to it, so I added an extra member variable, and an addVectors function, and moved the implementation from the defined constructor to the new function and just ended up calling that function in the defined constructor.

Creating an array isn't that difficult :) A matrix (2D/3D/...-array) is unfortunately a little bit different if you want to do it your way!

But first of all you should know about the stack and the heap!

Lets have a look at these 2:

Stack:

A stack variable/array/matrix/... is only valid between the nearest 2 -> {} <- which you normally call a "codeblock". The size of it was defined during the "compile time" (the time where the compiler translates your code into the machine language). That means the size of your array needs to be set.

Example:

#include <iostream> #define MACRO 128 int arraySize(int size){ std::cin >> size; return size; } int main() { //this is valid int intArray[128] = {}; //the size(here: 128) needs to be a number like //or a macro like 'MACRO' which is //compile-time-only as well //this is valid int intArray2[MACRO] = {}; //this is not valid! int intArray[size()] = {}; return 0; } 

Heap:

A heap variable/array/matrix/... is valid until you delete it. That also means that a heap var is created during the run-time(from starting your program until you close/stop it)! This is allows you to define it's size.

Example:

#include <iostream> #define MACRO 128 int arraySize(int size){ return size; } int main() { //this is valid int intArray[128] = {}; //the size(here: 128) needs to be a number like //or a macro like 'MACRO' whic is //compile-time-only as well //this is valid int intArray2[MACRO] = {}; //creating an array with a non-static size //works like this: //int can also be a 'bool' int* intArray = new int[arraySize()]; // ^ the star means you are pointing to //an adress inside of your memory which has //the size of an int (per element) //That's why they are called "pointers"! //Right now it points to the beginning of the //array. // ^ the keyword "new" says that //you are allocating memory on the heap. // ^ //then you have to say which kind of array //it is which is the same you gave the pointer // ^ //now you give it the size of that array //this time it can be return value or the size //of a variable //as I mentioned...you have to delete this array on your own //if you dont do that your program will crash //maybe not after starting but it will! //SO NEVER NEVER NEVER... forget about it delete intArray[]; //^ write delete // ^ //then the name of your array // ^ //at the end of it write these 2 brackets //thex say you wanna remove the whole array! //why? because you can also create/delete //heap variables not only arrays. return 0; } 

Creating a matrix on the heap is unfortunately not that easy. But it is essential to know how a 1D-array works before going to further dimensions! That's why I did this tutorial!

Klick here to see how to create a matrix on the heap

Klick here to learn more about the heap

Klick here to choose the best result of this theme

I hope I could help you :)!