C'deki bir işleve argüman olarak bir dizi geçirme

Question 1

Argüman olarak dizi içeren bir fonksiyon yazdım ve aşağıdaki gibi dizi değerini ileterek çağırdım.

void arraytest(int a[])
{
    // changed the array a
    a[0]=a[0]+a[1];
    a[1]=a[0]-a[1];
    a[0]=a[0]-a[1];
}

void main()
{
    int arr[]={1,2};
    printf("%d \t %d",arr[0],arr[1]);
    arraytest(arr);
    printf("\n After calling fun arr contains: %d\t %d",arr[0],arr[1]);
}

Bulduğum şey arraytest(), değerleri ileterek fonksiyonu çağırıyor olsam da , orijinal kopyası int arr[]değiştirildi.

Lütfen nedenini açıklar mısınız?

Question 2

Bir diziyi parametre olarak iletirken, bu

void arraytest(int a[])

tam olarak aynı anlama gelir

void arraytest(int *a)

böylece edilir ana değerleri değiştirerek.

Tarihsel nedenlerden ötürü, diziler birinci sınıf vatandaş değildir ve değer üzerinden geçirilemez.

Question 3

Tek boyutlu bir diziyi bir işlevde bağımsız değişken olarak geçirmek istiyorsanız , aşağıdaki üç yoldan biriyle biçimsel bir parametre bildirmeniz gerekir ve üç bildirim yöntemi de benzer sonuçlar üretir çünkü her biri derleyiciye bir tamsayı işaretçisinin gittiğini söyler. alınacak .

int func(int arr[], ...){
    .
    .
    .
}

int func(int arr[SIZE], ...){
    .
    .
    .
}

int func(int* arr, ...){
    .
    .
    .
}

Yani, orijinal değerleri değiştiriyorsunuz.

Teşekkürler !!!

Question 4

Diziyi kopya olarak geçirmiyorsunuz. Yalnızca dizinin ilk elemanının bellekte olduğu adresi gösteren bir göstericidir.

Question 5

Dizinin ilk elemanının adresini iletiyorsunuz

Question 6

C'deki diziler, çoğu durumda, dizinin kendisinin ilk öğesine bir göstericiye dönüştürülür. Ve ayrıntılı olarak işlevlere aktarılan diziler her zaman işaretleyicilere dönüştürülür.

İşte K & R2nd'den bir alıntı :

Bir dizi adı bir işleve iletildiğinde, iletilen şey ilk öğenin konumudur. Çağrılan işlev içinde, bu bağımsız değişken yerel bir değişkendir ve dolayısıyla bir dizi adı parametresi bir işaretçi, yani bir adres içeren bir değişkendir.

Yazı:

void arraytest(int a[])

yazmakla aynı anlama sahiptir:

void arraytest(int *a)

Yani, açıkça yazmamanıza rağmen, bir işaretçiyi geçtiğiniz ve böylece ana değerdeki değerleri değiştirdiğiniz gibidir.

Daha fazlası için gerçekten okumanızı öneririz bu .

Dahası, SO ile ilgili diğer cevapları burada bulabilirsiniz

Question 7

Dizinin ilk üyesinin bellek konumunun değerini iletiyorsunuz.

Bu nedenle, işlevin içindeki diziyi değiştirmeye başladığınızda, orijinal diziyi değiştirmiş olursunuz.

Unutmayın a[1]olduğunu *(a+1).

Question 8

C'de, birkaç özel durum dışında, bir dizi başvurusu her zaman dizinin ilk elemanına bir göstericiye "bozunur". Bu nedenle, bir dizi "değere göre" geçirmek mümkün değildir. Bir işlev çağrısındaki bir dizi, diziyi başvuruya göre iletmeye benzer şekilde işleve işaretçi olarak geçirilecektir.

DÜZENLEME: Bir dizinin ilk elemanına bir göstericiye bozulmadığı üç özel durum vardır:

sizeof aile aynı değil sizeof (&a[0]).
&aile aynı değil &(&a[0])(ve tamamen aynı değil &a[0]).
char b[] = "foo"ile aynı değil char b[] = &("foo").

Question 9

Çok boyutlu bir diziyi bir işleve argüman olarak iletmek. Bağımsız değişken olarak tek sönük bir diziyi aktarmak aşağı yukarı önemsizdir. 2 sönük diziyi geçmenin daha ilginç durumuna bir göz atalım. C'de int **2 dim dizi yerine construct ( ) işaretçisi için bir işaretçi kullanamazsınız . Bir örnek verelim:

void assignZeros(int(*arr)[5], const int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 5; j++) {
            *(*(arr + i) + j) = 0;
            // or equivalent assignment
            arr[i][j] = 0;
        }
    }

Burada, ilk argüman olarak 5 tam sayılık bir diziye işaretçi alan bir işlev belirledim. 5 sütunlu herhangi bir 2 dim dizisini bağımsız değişken olarak geçirebilirim:

int arr1[1][5]
int arr1[2][5]
...
int arr1[20][5]
...

Herhangi bir 2 sönük diziyi kabul edebilecek ve işlev imzasını aşağıdaki gibi değiştirebilecek daha genel bir işlev tanımlama fikri aklınıza gelebilir:

void assignZeros(int ** arr, const int rows, const int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            *(*(arr + i) + j) = 0;
        }
    }
}

Bu kod derlenir, ancak değerleri ilk işlevde olduğu gibi atamaya çalışırken bir çalışma zamanı hatası alırsınız. Yani C'de çok boyutlu diziler, işaretçilerden işaretçilerle aynı değildir ... işaretçiler. An int(*arr)[5], 5 öğeden oluşan diziye bir göstericidir, bir int(*arr)[6] 6 öğeden oluşan diziye bir göstericidir ve bunlar, farklı türlere işaretçilerdir!

Peki, daha yüksek boyutlar için fonksiyon argümanları nasıl tanımlanır? Basit, biz sadece kalıbı takip ediyoruz! Burada aynı işlev 3 boyutlu bir dizi alacak şekilde ayarlanmıştır:

void assignZeros2(int(*arr)[4][5], const int dim1, const int dim2, const int dim3) {
    for (int i = 0; i < dim1; i++) {
        for (int j = 0; j < dim2; j++) {
            for (int k = 0; k < dim3; k++) {
                *(*(*(arr + i) + j) + k) = 0;
                // or equivalent assignment
                arr[i][j][k] = 0;
            }
        }
    }
}

Beklediğiniz gibi, ikinci boyutta 4 öğe ve üçüncü boyutta 5 öğe bulunan herhangi bir 3 boyutlu diziyi bağımsız değişken olarak alabilir. Bunun gibi herhangi bir şey tamam olabilir:

arr[1][4][5]
arr[2][4][5]
...
arr[10][4][5]
...

Ancak ilk boyuta kadar tüm boyutları belirlememiz gerekiyor.

Question 10

Diziden ptr'ye doğal tür bozunumuyla C'de standart dizi kullanımı

@Bo Persson doğru onun büyük cevap devletler burada :

Bir diziyi parametre olarak iletirken, bu
void arraytest(int a[])
tam olarak aynı anlama gelir
void arraytest(int *a)

Bununla birlikte, yukarıdaki iki formun da şunu ekleyeyim:

tam olarak aynı demek
```
 void arraytest(int a[0])
```
bu tamamen aynı anlamına gelir
```
 void arraytest(int a[1])
```
bu tamamen aynı anlamına gelir
```
 void arraytest(int a[2])
```
bu tamamen aynı anlamına gelir
```
 void arraytest(int a[1000])
```
vb.

Yukarıdaki dizi örneklerinin her birinde, girdi parametresi türü bir değerine düşerint * ve derleme seçenekleri -Wall -Wextra -Werroraçık olsa bile hiçbir uyarı ve hata olmadan çağrılabilir ( bu 3 derleme seçeneğiyle ilgili ayrıntılar için burada depomuza bakın ) bu:

int array1[2];
int * array2 = array1;

// works fine because `array1` automatically decays from an array type
// to `int *`
arraytest(array1);
// works fine because `array2` is already an `int *` 
arraytest(array2);

Nitekim olarak, "boyut" değeri ( [0], [1], [2], [1000]dizi parametrenin içine, vs.) burada estetik / öz dokümantasyon amaçlı görünüşe bakılırsa, ve herhangi bir pozitif tam sayı olabilir ( size_tistediğiniz sanırım tip)!

Bununla birlikte, pratikte, işlevin almasını beklediğiniz dizinin minimum boyutunu belirtmek için kullanmalısınız, böylece kod yazarken izlemeniz ve doğrulamanız kolay olur. MISRA-C-2012 standardı ( al / burada £ 15.00 için standart 236-pg 2012-sürüm PDF bugüne kadar devlet (vurgu eklenmiştir) olarak geçer):

Kural 17.5 Bir dizi türüne sahip olduğu bildirilen bir parametreye karşılık gelen işlev bağımsız değişkeni, uygun sayıda elemana sahip olmalıdır.

...

Bir parametre belirtilen boyuta sahip bir dizi olarak bildirilirse, her işlev çağrısındaki karşılık gelen bağımsız değişken, en az dizi kadar öğeye sahip bir nesneyi işaret etmelidir.

...

Bir işlev parametresi için bir dizi tanımlayıcının kullanılması, işlev arabirimini bir işaretçi kullanmaktan daha açık bir şekilde belirtir. İşlev tarafından beklenen minimum eleman sayısı açıkça belirtilmiştir, ancak bu bir işaretçi ile mümkün değildir.

Başka bir deyişle, C standardı teknik olarak onu zorlamasa da, açık boyut biçimini kullanmanızı önerirler - en azından bir geliştirici olarak size ve kodu kullanan diğerlerine, işlevin hangi boyut dizisini beklediğini netleştirmeye yardımcı olur. geçmek için.

C'deki dizilerde tür güvenliğini zorlama

@Winger Sendon'un cevabımın altındaki bir yorumda işaret ettiği gibi, C'yi bir dizi tipini dizi boyutuna bağlı olarak farklı şekilde ele almaya zorlayabiliriz !

Öncelikle, kullandığınız, sadece yukarıda benim örnekte tanımak gerekir int array1[2];böyle: arraytest(array1);nedenleri array1otomatik çürüme bir içine int *. ANCAK, yerine adresini alıp ararsanız , tamamen farklı bir davranışla karşılaşırsınız! array1arraytest(&array1)Şimdi, bir int *! Bunun yerine, &array1is türü, "boyut 2 int dizisine işaretçi " veya " int türünde boyut 2 dizisine işaretçi"int (*)[2] anlamına gelir . Bu nedenle, bir dizide tür güvenliğini kontrol etmek için C'yi şu şekilde yapabilirsiniz:

void arraytest(int (*a)[2])
{
    // my function here
}

Bu sözdiziminin okunması zordur, ancak bir işlev göstericisininkine benzer . Çevrimiçi araç, cdecl , bize şunu söyler int (*a)[2]: "int dizisinin 2. dizisine işaretçi olarak bir işaretçi bildir " (2 ints dizisine işaretçi ). : Parantez olmadığı versiyon ile karıştırmayın Do NOT int * a[2], araçlar: "int pointer dizisi 2. olarak bir beyan" (2 dizisi işaretçiler için int).

Şimdi, bu işlev, bunu adres işleci ( &) ile bu şekilde çağırmanızı GEREKTİRİR , bir girdi parametresi olarak DOĞRU BOYUTLU BİR DİZAYA İŞARETLEYİCİ !:

int array1[2];

// ok, since the type of `array1` is `int (*)[2]` (ptr to array of 
// 2 ints)
arraytest(&array1); // you must use the & operator here to prevent
                    // `array1` from otherwise automatically decaying
                    // into `int *`, which is the WRONG input type here!

Ancak bu, bir uyarı oluşturacaktır:

int array1[2];

// WARNING! Wrong type since the type of `array1` decays to `int *`:
//      main.c:32:15: warning: passing argument 1 of ‘arraytest’ from 
//      incompatible pointer type [-Wincompatible-pointer-types]                                                            
//      main.c:22:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
arraytest(array1); // (missing & operator)

Bu kodu burada test edebilirsiniz .

C derleyicisini bu uyarıyı bir hataya dönüştürmeye zorlamak için, her zaman arraytest(&array1);yalnızca doğru boyut ve türde ( int array1[2];bu durumda) bir giriş dizisi kullanarak çağırmanız GEREKİR -Werror, derleme seçeneklerinize ekleyin . Yukarıdaki test kodunu onlinegdb.com'da çalıştırıyorsanız, bunu sağ üstteki dişli çark simgesini tıklayarak yapın ve bu seçeneği yazmak için "Ekstra Derleyici Bayrakları" na tıklayın. Şimdi, bu uyarı:

main.c:34:15: warning: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Wincompatible-pointer-types]                                                            
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’

bu yapı hatasına dönüşecek:

main.c: In function ‘main’:
main.c:34:15: error: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Werror=incompatible-pointer-types]
     arraytest(array1); // warning!
               ^~~~~~
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
 void arraytest(int (*a)[2])
      ^~~~~~~~~
cc1: all warnings being treated as errors

Ayrıca, belirli bir boyuttaki diziler için "güvenli tür" işaretçileri oluşturabileceğinizi unutmayın, örneğin:

int array[2];
// "type safe" ptr to array of size 2 of int:
int (*array_p)[2] = &array;

... ama yok illa bana C ++ dil sözdizimi karmaşıklığı, ayrıntı ve zorluk architecting kod olağanüstü yüksek maliyetle, her yerde kuvvet tip güvenliği için kullanılan antikalar çok hatırlatıyor olarak, bu tavsiye ve hangi ben sevmediğim ve daha önce defalarca mırıldandı (örn: burada "C ++ Üzerine Düşüncelerim" konusuna bakın ).

Ek testler ve deneyler için, hemen aşağıdaki bağlantıya da bakın.

Referanslar

Yukarıdaki bağlantılara bakın. Ayrıca:

Çevrimiçi kod denemem: https://onlinegdb.com/B1RsrBDFD

Question 11

a[]Veya kullanırsanız diziler her zaman referans olarak aktarılır *a:

int* printSquares(int a[], int size, int e[]) {   
    for(int i = 0; i < size; i++) {
        e[i] = i * i;
    }
    return e;
}

int* printSquares(int *a, int size, int e[]) {
    for(int i = 0; i < size; i++) {
        e[i] = i * i;
    }
    return e;
}