Poprawne zwracanie tablicy o określonej liczbie elementów

Question

Jak w poprawny sposób zwrócić z funkcji np. 10 elementową tablice, tak żeby tablica zwracana zapisała się do zmiennej która również jest 10 elementową tablicą.
W pliku z funkcjami mam coś takiego:
 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdlib.h>
#include "header.h"

int menu(){
    int g=0, liczba=0;
    int tab[10];
    printf("Wybierz ktore zadanie pokazac:\n");
    printf("1. zadanie 1\t2. zadanie 2\t3. zadanie 3\t4. zadanie 4\n");
    printf("k. koniec\n");
    switch(getchar()) {
    case '4':
        //o ten moment dokladnie chodzi
        *tab = zad_4_wypelnienie();
        printf("%d\t%d\t%d\t%d\t%d\t%d\t", tab[0],tab[1],tab[2],tab[3],tab[4],tab[5]);
        printf("Jakiej liczby szukac?\n");
        clearIn();
        scanf("%d", &liczba);
        zad_4(tab, liczba);
        break;

A tak wygląda sama funkcja:
 

int* zad_4_wypelnienie() {
    static int tablica[10];
    srand(time(0));
    for(int i = 0; i<10; i++){
        tablica[i]=rand() % 10 + 1;
        printf("%d\t", tablica[i]);
        }
        endl();
    return tablica;
}

Dodam że w pliku nagłówkowym mam prototyp ww. fukncji.
Gdy w taki sposób zwracam tablice to w zmiennej do jakiej ją przypisuję zazwyczaj zgadza się tylko pierwsza liczba a reszta to 0 albo random.

Pomóżcie ;/

Answer 1

Jak nie chcesz alokacji dynamicznej, to jesteś skazany albo na stałą wielkość tablicy albo na tablice VLA które występują tylko w C (nie w C++). Tu masz przykład stałej wielkości (10 elementowej) tablicy oraz VLA. Pamiętaj tylko że brak alokacji dynamicznej ma konsekwencje związane z wielkością tablicy. Nie przekroczysz zajętości ~2 MB (orientacyjnie w zależności od ustawień systemu operacyjnego) bo pamięć jest alokowana jest na stosie.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdlib.h>

/* Uwaga: Reguła DRY naruszona dla łatwiejszego analizowania
 * pojedynczego przykładu.
 */
typedef int table_t[10];
static const size_t table_length = sizeof(table_t) / sizeof(int);

void fill_table(table_t table) {
    srand(time(NULL));
    for(size_t i = 0; i < table_length; ++i) {
        table[i] = rand() % 10 + 1;
    }
}

void show_table(table_t table) {
    for(size_t i = 0; i < table_length; ++i) {
        printf("%d\t", table[i]);
    }
    putchar('\n');
}

void fill_vla_table(int * table, size_t length) {
    srand(time(NULL));
    for(size_t i = 0; i < length; ++i) {
        table[i] = rand() % 10 + 1;
    }
}

void show_vla_table(int * table, size_t length) {
    for(size_t i = 0; i < length; ++i) {
        printf("%d\t", table[i]);
    }
    putchar('\n');
}

int main(void) {
    table_t table;
    fill_table(table);
    show_table(table);

    printf("Podaj wielkość tablicy VLA: ");
    size_t length;
    scanf(" %lu", &length);
    int table_vla[length];
    fill_vla_table(table_vla, length);
    show_vla_table(table_vla, length);

    return EXIT_SUCCESS;
}

 

Comments

Woah! Dzięki wam! Doszczętnie wytłumaczone na każdy sposób. Właśnie tak chciałem ;)

Answer 2

int* zad_4_wypelnienie() {
    int *tablica = (int*)malloc(10*sizeof(int));
    srand(time(0));
    for(int i = 0; i<10; i++){
        tablica[i]=rand() % 10 + 1;
        printf("%d\t", tablica[i]);
    }
    endl(); 
    return tablica;
}

Comments

Rozumiem że bez alokowania pamięci nie przejdzie :)?

EDIT: A gdzie potem musiałbym zwolnić pamięć? dopiero na samym końcu programu?

---

Gdzie chcesz. Zależy od ciebie.