Question

call from main

matrix_multiplication(arrayA,arrayB,row1,col1,col2);

function definition

float matrix__multiplication(float **arrayA,float **arrayB,int row1,int col1,int col2)
{
float result[row1][col2];
result[][]=....

return result;
}

I wanted to know how to pass 2d arrays in function call,
how to receive in function definition
and how to return the result matrix?

Answer 1

Using raw pointers for your arrays like this is more C style than C++. Use vector of vector (indexing is still very efficient).

size_t rows(5);
size_t columns(15);
vector<float> row(columns);
vector<vector<float>> matrix(rows, row);
matrix[0][0] = 0.1f;

Better yet wrap the underlying storage in a Matrix class that implements the required matrix operations, holds and enforces dimensions, ensures matrices are compatible for the multiplication, and so on.

class Matrix
{ 
public:
  Matrix(const int _rows, const int _cols) : rows(_rows), cols(_cols)
  {
  }

  Matrix Multiply(const Matrix& rhs);

private:
  vector<vector<float>> storage;
  size_t rows;
  size_t cols;
};

Matrix Matrix::multiply(const Matrix& rhs)
{
  Matrix result(*this, rhs);   // construct matrix of right dimensions
  // multiply the operands
  return result;     // modern compilers do not copy construct the result
}

If your matrix demands are complex you could consider a library like Boost.UBlas versus roll your own. This is templated code and supports specializations for sparse, diagonal and other common types of matrix.