Как передать массив в функцию и вернуть его?

int A[3] = {1,2,3};
int Func(int Array[]){
for(i = 0; i < 3; i++){
   Array[i] =+1;
}
return Array;
}

Дело в том что в C++ в функцию можно передать только указатель (или ссылку) на массив, соответственно вы всегда будете работать с исходным массивом, а не с его копией (и вернете также указатель на исходный массив):

int* Func(int *Array)
{
    for(i = 0; i < 3; i++) {
       Array[i]++;
    }
    return Array;
}

Так же этот код не учитывает размер массива (цикл проходит строго три раза), что может привести к следующему:

• если длина входного массива больше 3: обработаны будут только первые три элемента массива;
• если длина входного массива меньше 3: программа упадет с грохотом и ошибкой доступа к памяти.

Проблему с размером можно решить двумя путями: передавать в функцию дополнительно размер массива или передавать массив по ссылке (если передавать массив по ссылке, ошибки с тем, что вы передали или вернули массив неправильного размера будут выявлены на стадии компиляции):

int* Func(int* Array, int size) {...}  // передача размера, тогда цикл будет for (int i = 0; i < size; i++)
int (& Func(int (&Array)[3]))[3] {...} // передача по ссылке, тогда цикл будет for (int i = 0; i < 3; i++)

В обоих случаях вернется указатель (или ссылка) на исходный массив. Но смысла возвращать что либо из функции в таком случае нет, вы просто можете продолжать использовать старую переменную.

Чтобы вернуть новый массив, придется просто внутри функции выделить память под новый массив и вернуть указатель на нее (главное потом не забыть очистить память):

int* Func(int* Array, int size)
{
    int *new_array = new int[size];
    for(int i = 0; i < size; i++) {
       new_array[i] = Array[i] + 1;
    }
    return new_array;
}

Но у нас же C++, черт возьми, так что стоит вместо стандартных сишных массивов воспользоваться теми контейнерами, которые предоставляет Родина STL:

• std::vector<type> такой "массив" с изменяемым размером;
• std::array<type, size> массив фиксированного размера.

Теперь мы можем использовать итераторы, Range-based for loop (начиная с C++11) и прочие прелести:

std::vector<int> Func(std::vector<int> Array) // пример с vector и циклом со счетчиком
{
    for (int i = 0; i < Array.size(); i++) {
        Array[i]++;
    }
std::array<int, 3> Func(std::array<int, 3> Array) // с array и крутым циклом с итераторами
{
    for (std::array<int, 3>::iterator it = Array.begin(); it < Array.end(); it++) {
        *i++;
    }
    return Array;
}

Не знаток в C++ но могу сказать, что вы не передаете массив, а передаете функии указатель на его первый элемент. В таком случае вы работаете не с локальной копией массива, а с его указателем.

Если задача функции int Func(int Array[]) состоит в том чтоб модифицировать "переданный массив" вам совсем не обязательно возващать его, а если вам очень уж хочется что-то возвратить в место вызова (что в данном случае бессмысленно) - то нужно изменить сиганатуру функции:

int* Func(int Array[]) {
    for(i = 0; i < 3; i++) {
        Array[i] += 1; // тут наверно так. Операция =+ не имеет смысла.
    }
    return Array;
}

Заметьте, возвращаемый тип int* это указатель на int.

Передаётся указатель на массив и работа ведётся напрямую с ним, следовательно, вовсе необязательно делать возврат, например:

void Func(int* array, size_t arraySize){
  for(size_t i = 0; i < arraySize; i++) {
    array[i] += 1;
  }
}

Как пример, функция getSorted принимает массив source (int[]) и его размер. Делает копию, сортирует и возвращает отсортированный массив.

int* getSorted(int * source, int size)
{
    int *rc = (int* ) malloc(sizeof(int)*size); // исправлено 
    int tmp = 0;
    for (int i = 0; i < size; i++)
        rc[i] = source[i];
    for (int i = 1; i < size; i++)
    {
        for (int r = 0; r < (size - i); r++)
        {
            if (rc[r] > rc[r + 1])
            {
                tmp = rc[r];
                rc[r] = rc[r + 1];
                rc[r + 1] = tmp;
            }
        }
    }
return &rc[0];
}

Пример вызова:

int * target;
int source[10];
....
// заполнение массива source
source[0] = 12;....
...
target =  getSorted(source, 10);
// дальше c target обращаемся как с массивом
int m = target[3];