Заполнение массива с++

void filling (int ar[][size])
{
    srand(time(0));
    for (int r=0; r<size; r++)
        for (int c=0; c<size; c++)
        {
        res:
            ar[r][c]=rand()%16;
            for (int e=r; r>=0; e--)
                 for (int x=c; c>=0; x--)
                      if (ar[r][c] == ar[e][x]) goto res;
        }
}

Вот пример с cplusplus.com. Думаю, это как раз то, что Вам надо. основная идея - заполняете массив числами из нужного диапазона, а потом просто случайно перемешиваете.

// random_shuffle example
#include <iostream>     // std::cout
#include <algorithm>    // std::random_shuffle
#include <vector>       // std::vector
#include <ctime>        // std::time
#include <cstdlib>      // std::rand, std::srand
// random generator function:
int myrandom (int i) { return std::rand()%i;}
int main () {
  std::srand ( unsigned ( std::time(0) ) );
  std::vector<int> myvector;
 // set some values:
 for (int i=1; i<16; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9 ...
 // using built-in random generator:
 std::random_shuffle ( myvector.begin(), myvector.end() );
 // using myrandom:
 std::random_shuffle ( myvector.begin(), myvector.end(), myrandom);
 // print out content:
 std::cout << "myvector contains:";
 for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';
  return 0;
}

Пример немного избыточен, т.к. там показано как для перемешивания использовать еще и свою функцию (там можно не только равномерное распределение использовать). И естественно, для большей эффективности, можно еще добавить резервирование места в векторе перед добавлением элементов. Но для маленьких выборок - и так сойдет. Главная строчка здесь: std::random_shuffle ( myvector.begin(), myvector.end() );.

Что касается двумерности... В функцию его можно передавать как одномерный int *arr, но не забудьте передать и правильный размер. И потом можно просто скопировать содержимое вектора в Ваш массив (если по какой-то причине нельзя изначально работать с векторами).

void filling (int ar[][4]) {   
   std::vector<int> v(15, 1);
   std::partial_sum(v.begin(), v.end(), v.begin());
   std::random_shuffle(v.begin(), v.end());
   std::copy(v.begin(), v.end(), ar[0]);
}

собственно можно заполнить так любой массив с любым количеством цифр. Можно например и так

int f() {
    static int k = 0;
    return ++k;
}
void filling (int ar[][4]) { 
    std::generate(m[0], &m[3][3], f);
    std::random_shuffle(m[0], &m[3][3]);
}

Беспонтово и быстро заполнить такой массив можно, используя линейный конгруэнтный генератор как для значения, так и для индекса массива

void filling(int ar[][size]) {
    int *ar1 = &ar[0][0];    // массив любой мерности в c++ хранится смежно
    int m = 16;              // модуль ЛКГ
    int a = 5;               // множитель ЛКГ
    int c = 7;               // смещение ЛКГ
    int x = rand() % m;      // начальное значение элемента массива
    for (int i = 0; i < m; i++) {
        x = (a * x + c) % m; // очередное значение элемента массива
        ar1[i] = x;          // запиcываем
}   }

При указанных в примере коэффициентах будет выдана последовательность из 16-и неповторяющих чисел, которая используется в качестве элементов массива по индексу, равному счетчику цикла. Можно и наоборот -- ЛКГ генерирует индексы, а пишутся счетчики цикла.

Требования, которым должны удовлетворяь коэффициенты и модуль ЛКГ, приведены в википедии. Приведенный алгоритм без изменений работает для любых массивов любой размерности.