Функция, возвращающая измененный массив

@route66 · Регистрация: 29.04.2011

Author24 — интернет-сервис помощи студентам

Как определить функцию, возвращающую модифицированный массив?
Например:

Код

Вход в функцию: {-1, 2, -3, 4}. 
Выход: функция возвращает новый массив: {2, 4}.

В Pascal/Delphi достаточно объявить пользовательский тип "массив" и назначить его функции в качестве возвращаемого типа.
На списках в Лиспе - очень просто (в примере функция возвращает массив неотрицательных чисел):

Lisp

(defun F (l)
    (cond 
        ((null l) nil)
        ((< (car l) 0) (F (cdr l)))
        (t (cons (car l) (F (cdr l))))))

Или еще проще:

Lisp

1 2	(defun F (l) (remove-if 'minusp l))

Результат:

Lisp

1	(F '(-1 2 -3 4 -5 6 7 -8)) ==> (2 4 6 7)

А как это делается на Си? Привожу пример неудачной попытки это сделать (функция remove_if). На выходе получается "мусор". (см. вложенный скриншот). Хотя сама функция работает корректно: так, если организовать внутри функции цикл и вывести массив полученный массив b, то результатом будет верная последовательность: b = {2,4,6,7}.
Как полученный массив правильно передать "основной программе"? Исправьте пример или приведите свой.

C

#include <stdio.h>
#include <stdlib.h>
#define N 8
 
// -----------------------------------------------------------------------------
//                                        Вернуть массив положительных элементов
int * remove_if (int *a, int size, int *n) { 
    
    int i,j,b[N];
    
    for (i=0, j=0; i<size; i++){
        if (a[i] >= 0) {
            b[j] = a[i]; 
            j++;
        }
    }
    // for (i=0; i<j; i++) printf("%d ",b[i]); // b = {2,4,6,7}. Результат верный.
    *n = j;     // Число положит. элементов
    return *b;  // Возвр. массив
}
 
// -----------------------------------------------------------------------------
//                                                                       Печать
int print_array (int *a, int n){ // 
    int i; 
    
    printf("\n Array: \n");
    for (i=0; i<n; i++)
        printf(" %d ",a[i]);
    printf("\n "); 
}
 
// -----------------------------------------------------------------------------
int main(){
 
    int i,b[N],n,a[N] = {-1, 2, -3, 4, -5, 6, 7, -8};
    
    
    print_array (a,N);                                         
    *b = remove_if(a, N, &n); 
    printf("\n\n Total positive elems: %d  \n\n",n);
    print_array (b,n);                //for (i=0; i<n; i++) printf("%d ", b[i]);
    
    
    system("PAUSE");
    return 0;
}

Charles Kludge · 06.01.2014, 14:00

Да легко. Просто вы возвращаете указатель на локальный массив, хранящийся в стеке, который при выходе из ф-ции заполняется хламом, отсюда и граблемы.

C

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define N 8
 
// -----------------------------------------------------------------------------
//                                        Вернуть массив положительных элементов
int * remove_if (int *src, int *size) { 
    
    int i,j, *dst;
    dst = malloc((*size)*sizeof(int)); // выделяем память размером с исходный массив
    for (i=0, j=0; i<(*size); i++){
        if (src[i] >= 0) {
            dst[j] = src[i]; 
            j++;
        }
    }
    dst = realloc(dst,j*sizeof(int)); // уменьшаем до нужного размера
    // for (i=0; i<j; i++) printf("%d ",b[i]); // b = {2,4,6,7}. Результат верный.
    (*size) = j;     // Число положит. элементов
    return dst;  // Возвр. массив
};
 
// -----------------------------------------------------------------------------
//                                                                       Печать
void print_array (int *a, int n){ // 
    int i; 
    
    printf("\n Array: \n");
    for (i=0; i<n; i++)
        printf(" %d ",a[i]);
    printf("\n "); 
};
 
// -----------------------------------------------------------------------------
int main(){
 
    int i,*b,n,a[N] = {-1, 2, -3, 4, -5, 6, 7, -8};
    
    
    print_array (a,N);                                         
    n = N;
    b = remove_if(a, &n); 
    printf("\n\n Total positive elems: %d  \n\n",n);
    print_array (b,n);                //for (i=0; i<n; i++) printf("%d ", b[i]);
    free(b);    //  не забывайте освобождать память перед повторным использованием
    getch();
//    system("PAUSE");
    return 0;
}

@route66 · 09.01.2014, 19:02 **[ТС]**

Charles Kludge, спасибо, здесь всё понятно!
А как проделать аналогичные действия с матрицей? Просто выделить память под указатель (*b)[] на массив и правильно передать матрицу "основной программе". Моя реализация неработоспособна - программа просто вылетает до завершения.

C

#include <stdio.h>
#include <stdlib.h>
//#include <conio.h>
#define N 4
 
// -----------------------------------------------------------------------------
//                                                             Печать матрицы
void print_matrix (int (*a)[N], int n, int m){ // или a[][N], или a[N][N]
    
    int i,j;
    
    for (i=0; i<n; i++){
        for (j=0; j<n; j++){
            printf(" %d ",a[i][j]);
        }
        printf("\n");
    }
}
 
// -----------------------------------------------------------------------------
//                                                             Вернуть матрицу
int (* matrix (int (*a)[N], int n, int m))[N]{
    
    int i,j; 
    int (*b)[m] = (int *) malloc(sizeof(int) * n * m);  // выделить память
    b = (*a)[m];                                        // связать с указателем b
    
    return b;   // возвр. матрицу
    //return a;
}
 
// -----------------------------------------------------------------------------
int main(){
    
    int i,j,n,*b, a[N][N] = {{1,2,3,4},{5,6,7,8},{9,1,2,3},{4,5,6,7}};
    print_matrix(a,N,N);
    
    b = matrix(a,N,N);
    print_matrix(b,N,N);
    
    system("PAUSE"); //getch();
}

@gng · 10.01.2014, 00:20

Что-то типа такого. Хотя не знаю, насколько оправдано здесь использовать указатели на массив. Я бы использовал int* во всех случаях.

C

int (* matrix (int (*a)[N], int n, int m))[N]{
 
  int (*b)[N] = (int (*)[N])  malloc(sizeof(int) * n * m);  // выделить память
  memcpy (b, a, n * m * sizeof (int));                          // копируем туда массив
  b[0][0]= 17;
 
  return b;   // возвр. матрицу
}

Если вам надо саму матрицу "a" изменить, просто меняете значения элементов, и возвращаете её же.

@route66 · 10.01.2014, 16:29 **[ТС]**

Сообщение от gng

Что-то типа такого. Хотя не знаю, насколько оправдано здесь использовать указатели на массив. Я бы использовал int* во всех случаях.

C

int (* matrix (int (*a)[N], int n, int m))[N]{
 
  int (*b)[N] = (int (*)[N])  malloc(sizeof(int) * n * m);  // выделить память
  memcpy (b, a, n * m * sizeof (int));                          // копируем туда массив
  b[0][0]= 17;
 
  return b;   // возвр. матрицу
}

Если вам надо саму матрицу "a" изменить, просто меняете значения элементов, и возвращаете её же.

Спасибо. Заменил на вашу функцию - теперь программа работает и нулевой элемент изменен. Но куча ворнингов о неправильном объявлении типа.
А возможно сделать как-то проще, без вспомогательной ф-ции memcpy() или вообще без типа "матрицы": ( int (* matrix (int (*a)[N], int n, int m))[N]), т.е. возвращаемое значение функции выразить, как обыкновенный указатель на целый тип: int * matrix (int (*a)[N], int n, int m)?

@gng · 10.01.2014, 20:30

Сообщение от route66

о куча ворнингов о неправильном объявлении типа.

В других функцих также должны быть объявлены соответствующие типы.

C

int main(){
  int a[N][N] = {{1,2,3,4},{5,6,7,8},{9,1,2,3},{4,5,6,7}};
 
  print_matrix(a,N,N);
  int (*b)[N] = matrix(a,N,N);
  print_matrix(b,N,N);
  return 0;
}

Сообщение от route66

А возможно сделать как-то проще, без вспомогательной ф-ции memcpy()

Вы выделяете память под новую матрицу. memcpy копирует туда вашу матрицу.
Другой выринт - модифицировать cуществующую матрицу.
Использование memcpy, strcmp и т.д. - это стиль языка Cи. В плюсах часто пишут по-другому - создают классы и исспользуют оператор присваивания "=".

Сообщение от route66

возвращаемое значение функции выразить, как обыкновенный указатель на целый тип

Да. Мне, например, так ближе.

@route66 · 12.01.2014, 15:10 **[ТС]**

Сообщение от gng

Да. Мне, например, так ближе.

Спасибо, всё работает, как Вы написали.
Теперь пробую передать указатель на матрицу, как обычный указатель на массив.
Но при попытке присвоить значение элементу матрицы b[0][0] - ошибка: "subscripted value is neither array nor pointer nor vector".
Если опустить строку (b[0][0]=17), то print_matrix(c,N,N) вернет матрицу, но с оговоркой компилятора про несовместимость типа указателя:
[Warning] passing argument 1 of 'print_matrix' from incompatible pointer type [enabled by default].
Как это можно исправить?

C

int * matrix2 (int (*a)[N], int n, int m){
 
    int * b = malloc(sizeof(int) * n * m);  // выделить память
    memcpy (b, a, n * m * sizeof (int));                 // копируем туда массив
    //b[0][0]= 17;  //subscripted value is neither array nor pointer nor vector
 
    return b;   // возвр. матрицу
}
// -----------------------------------------------------------------------------
int main() {
 
    int a[N][N] = {{1,2,3,4},{5,6,7,8},{9,1,2,3},{4,5,6,7}};
    print_matrix(a,N,N);
    
    int *c = matrix2(a,N,N);
    print_matrix(c,N,N);
 
}

@gng · 12.01.2014, 17:08

Вариант 1 - преобразование к типу указателя на массив из N целых чисел. (удобен, если количество столбцов заранее известно)

C

1	int (b)[N] = (int ()[N])matrix2(a,N,N);

Вариант 2. - везде используется int*
Тогда, при N столбцах, доступ к элементу (i,j)

C

b[i*N+j]

или, что то же самое

C

1	(b+iN+j)

При этом N может быть не известен на стадии компиляции.

Выриант 3 - отдельно выделяется память под каждую строку и идет работа с массивом указателей

C

1 2	int *e= malloc (N sizeof (int)); for (i= 0; i < N; i++) e[i]= malloc (N sizeof (int));