C++ tablica wypełniona losowo liczbami 0 i 1

No więc mam do napisania program, używając funkcji. W tablica ma być wypełniona losowo liczbami 0 i 1, a potem funkcja ma wyliczyć w którym wierszu jest najwięcej jedynek.
Mam coś takiego.

#include <iostream>
#include <cstdlib>
using namespace std;

//*************************************************
int fun3(rozmiarX, rozmiarY, tab[][100]);
//*************************************************

int main()
{
	const int roz = 10;
	int tabA[roz][roz];
	for (int k = 0; k <= roz; k++)
	{
		for (int l = 0; l <= roz; l++)
		{
			tabA[k][l] = rand() % 2;
			cout << tabA[k][l] << " ";
		}
	cout << "\n";
	}
	fun3(roz, roz, tabA);

	return 0;
}
//*******************************************************

int fun3 (int rozmiarX, int rozmiarY, int tabB[][100])
{	
	int roz_x = rozmiarX;
	int tabC[roz_x];
	for (int i = 0; i<= rozmiarX; i++)
	{
		for (int j = 0; j <= rozmiarY; j++)
		{
			if (tabC[i][j] = 1)
				tabC[i] += 1;
		}
	}
	int maks = 0;
	for (int i = 0; i <= rozmiarX; i++)
	{
		if (tabC[i] > maks)
		tabB[i] = maks;
	}
	return maks;
}
 

lecz kompilator krzyczy

 tablice.cpp: In function ‘int fun3(int, int, int (*)[100])’:
tablice.cpp:60:16: warning: ISO C++ forbids variable length array ‘tabC’ [-Wvla]
  int tabC[roz_x];
                ^
tablice.cpp:65:17: error: invalid types ‘int[int]’ for array subscript
    if (tabC[i][j] = 1)
                 ^
tablice.cpp:73:11: error: incompatible types in assignment of ‘int’ to ‘int [100]’
   tabB[i] = maks;
           ^
tablice.cpp:76:1: warning: no return statement in function returning non-void [-Wreturn-type]
 }
 ^

Byłby ktoś skłonny dać jakąś podpowiedź, co jest źle, co do poprawki ?

<font color="black">w C++ nie ma VLA - jeśli chcesz mieć dynamiczną tablicę, to użyj new type[size]
Pół-gotowiec dla Ciebie:</span>

#include <iostream>
#include <vector>
#include <random>
#include <algorithm>
#include <functional>
using namespace std;

template<typename T>
struct matrix{
    matrix(size_t width, size_t height): 
    	_width(width), 
    	_height(height), 
    	_data(width*height){}
 
    auto width() const
    { return _width; }
    
    auto height() const
    { return _height; }
 
    auto *operator[](size_t idx)
    { return _data.data() +(idx * _height); }
    const auto *operator[](size_t idx) const
    { return _data.data() +(idx * _height); }
    
    auto begin()
    { return ::begin(_data); }
    auto begin() const
    { return ::begin(_data); }
    
    auto end()
    { return ::end(_data); }
    auto end() const
    { return ::end(_data); }
private:
    size_t _width, _height;
    vector<T> _data;
};

int main(){
	size_t w = 10, h = 10;
	matrix<bool> mtx(w, h);
	default_random_engine generator;
	bernoulli_distribution distribution;
	generate(begin(mtx), end(mtx), bind(distribution, generator));
	return 0;
}

deklaracje z góry wywal, i daj po prostu tam definicje, to błąd generuje przyjnajmniej u mnie; z tabC probujesz zrobic tablice dwuwymiarowa a zadeklarowałeś ją kawałek wyżej jak jednowymiarową, to do poprawki jest na bank

Tworzysz jednowymiarową tablice tabC a potem odwołujesz się do niej jakby była ona dwuwymiarowa. Nie jestem pewien ale tu może tkwić problem.

tabC[] ma jeden wymiar nie możesz zrobić czegoś takiego jak tabC[][]... to tak jakbyś chciał włożyć do 2 szuflad coś... ale jest tylko jedna

Nit: Mozesz skorzystac z rand() w taki sposob ze czytasz bity tej minimum 16-bitowej liczby ktora Ci wylosuje

Dobra, już chyba doszedłem o co chodzi.
A teraz takie pytanie, to jest mój kawałek kodu

 int maks = 0;
	for (int i = 0; i <= roz_x; i++)
	{
		if (tabC[i] > maks)
		maks = tabC[i];
	}

sprawdzam która wartość jest maksymalna.
Podpowiedziałby ktoś, w jaki sposób potem odczytać indeks tej wartości maksymalnej ?

Zapisz sobie do innej zmiennej wartość i.

Wpadłem w sumie na to zaraz po tym jak napisałem posta ;D

#include <iostream>
#include <cstdlib>
using namespace std;

//*************************************************
int fun3(int rozmiarX, int rozmiarY, int tabA[][10]);
//*************************************************

int main()
{
	const int roz = 10;
	int tabB[roz][roz];
	for (int k = 0; k <= roz; k++)
	{
		for (int l = 0; l <= roz; l++)
		{
			tabB[k][l] = rand() % 2;
			cout << tabB[k][l] << " ";
		}
	cout << "\n";
	}
	fun3(roz, roz, tabB);

	return 0;
}
//*******************************************************

int fun3 (int rozmiarX, int rozmiarY, int tabA[][10])
{	

	int roz_x = rozmiarX;
	int roz_y = rozmiarY;
	int tabC[roz_x] = {0};
	for (int i = 0; i <= roz_x; i++)
	{
		for (int j = 0; j <= roz_y; j++)
		{
			if (tabA[i][j] == 1)
				tabC[i] += 1;
		}
	}
	int pozycja;
	int maks = 0;
	for (int i = 0; i <= roz_x; i++)
	{
		if (maks < tabC[i])
		{
			maks = tabC[i];
			pozycja = i;
		}
		
	}
	return pozycja;
}
 

teraz z kolei jest inny problem, jak wcześniej tworzyła mi się normalnie tablica [10][10] ładnie pięknie, to teraz tworzy się nieskończona tablica i nie chce przestać wstawiać tych zer i jedynek..

for (int k = 0; k < roz; k++)
    {
        for (int l = 0; l <roz; l++)
        {
            tabB[k][l] = rand() % 2;
            cout << tabB[k][l] << " ";
        }
    cout << "\n";
    } 

Naucz się kombinować, mi jak coś nie działa i nie wiem do końca co, to usuwam coś z myślą "co się stanie jak wyrzuce to" i tak szukam :D