Écrire le prototype d'une fonction qui prend un tableau d'exactement 16 entiers

En C, cela nécessite un pointeur vers un tableau d'entiers 16:

void special_case(int (*array)[16]);

Il serait appelé à:

int array[16];
special_case(&array);

En C++, vous pouvez utiliser une référence à un tableau, aussi, comme le montre Nawaz's réponse. (La question demande C dans le titre, et à l'origine uniquement mentionné en C++ dans les balises.)

---

Une version qui utilise une variante de:

void alternative(int array[16]);

finit par être équivalent à:

void alternative(int *array);

qui acceptera n'importe quelle taille de tableau, dans la pratique.

---

La question se pose - t special_case() vraiment empêcher une taille différente de la matrice d'être transmis. La réponse est "Oui".

void special_case(int (*array)[16]);

void anon(void)
{

    int array16[16];
    int array18[18];
    special_case(&array16);
    special_case(&array18);
}

Le compilateur (GCC 4.5.2 sur mac os X 10.6.6, comme il arrive) se plaint (avertit):

$ gcc -c xx.c
xx.c: In function ‘anon’:
xx.c:9:5: warning: passing argument 1 of ‘special_case’ from incompatible pointer type
xx.c:1:6: note: expected ‘int (*)[16]’ but argument is of type ‘int (*)[18]’
$

Changement de GCC 4.2.1 - tel que fourni par Apple, et que l'avertissement est:

$ /usr/bin/gcc -c xx.c
xx.c: In function ‘anon’:
xx.c:9: warning: passing argument 1 of ‘special_case’ from incompatible pointer type
$

L'avertissement 4.5.2 est mieux, mais le fond est le même.

& qui est nécessaire en C++:

void foo(int (&a)[16]); //& is necessary. (in C++)

Remarque : & est nécessaire, sinon vous pouvez passer de tableau de n'importe quelle taille!

---

Pour C:

void foo(int (*a)[16]) //one way
{
}

typedef int (*IntArr16)[16]; //other way
void bar(IntArr16 a)
{
}

int main(void) 
{
        int a[16];
        foo(&a); //call like this - otherwise you'll get warning!
        bar(&a); //call like this - otherwise you'll get warning!
        return 0;
}

Démo : http://www.ideone.com/fWva6

Vous déjà reçu quelques réponses pour C, et une réponse pour le C++, mais il y a une autre manière de le faire en C++.

Que Nawaz dit, pour passer un tableau de taille N, vous pouvez le faire en C++:

const size_t N = 16; //For your question.

void foo(int (&arr)[N]) {
    //Do something with arr.
}

---

Toutefois, comme du C++11, vous pouvez également utiliser les std::array conteneur, qui peut être transmis avec la plus naturelle de la syntaxe (en supposant une certaine familiarité avec la syntaxe du modèle).

#include <array>

const size_t N = 16;

void bar(std::array<int, N> arr) {
    //Do something with arr.
}

Comme un conteneur, std::array permet essentiellement la même fonctionnalité qu'un normal C-gamme de style, tout en ajoutant des fonctionnalités supplémentaires.

std::array<int, 5> arr1 = { 1, 2, 3, 4, 5 };
int arr2[5] = { 1, 2, 3, 4, 5 };

//Operator[]:
for (int i = 0; i < 5; i++) {
    assert(arr1[i] == arr2[i]);
}

//Fill:
arr1.fill(0);
for (int i = 0; i < 5; i++) {
    arr2[i] = 0;
}

//Check size:
size_t arr1Size = arr1.size();
size_t arr2Size = sizeof(arr2) / sizeof(arr2[0]);

//Foreach (C++11 syntax):
for (int &i : arr1) {
    //Use i.
}
for (int &i : arr2) {
    //Use i.
}

Mais, à ma connaissance (qui est certes limitée dans le temps), de l'arithmétique des pointeurs n'est pas en sécurité avec std::array, sauf si vous utilisez la fonction de membre de data() pour obtenir le tableau réel de l'adresse en premier. C'est à la fois de prévenir de futures modifications à la std::array classe à partir de la rupture de votre code, et parce que certains STL implémentations peuvent stocker des données supplémentaires en plus du tableau réel.

---

Noter que cette solution serait la plus utile pour le nouveau code, ou si vous convertissez votre pré-code existant pour utiliser std::tableaux au lieu de C-style de tableaux. Comme std::les tableaux sont les types d'agrégats, ils manquent personnalisée, les constructeurs, et donc vous ne pouvez pas passer directement à partir de C-gamme de style à std::array (court de l'aide d'un plâtre, mais c'est laid et peut potentiellement causer des problèmes dans l'avenir). Pour les convertir, vous devez utiliser quelque chose comme ceci:

#include <array>
#include <algorithm>

const size_t N = 16;

std::array<int, N> cArrayConverter(int (&arr)[N]) {
    std::array<int, N> ret;

    std::copy(std::begin(arr), std::end(arr), std::begin(ret));

    return ret;
}

Par conséquent, si votre code utilise de style C tableaux et il serait impossible de convertir de façon à utiliser std::tableaux au lieu de cela, vous feriez mieux de coller avec le style C tableaux.

(Note: j'ai spécifié les tailles de N de sorte que vous pouvez réutiliser plus facilement le code chaque fois que vous en avez besoin.)

---

Edit: Il y a quelques choses que j'ai oublié de mentionner:

1) La majorité de la norme C++ des fonctions de la bibliothèque conçue pour une utilisation sur les conteneurs sont de mise en œuvre-agnostique; au lieu d'être conçu pour des conteneurs spécifiques, ils fonctionnent sur des plages, en utilisant les itérateurs. (Cela signifie également qu'ils travaillent pour std::basic_string et les instanciations de celle-ci, comme std::string.) Par exemple, std::copy a le prototype suivant:

template <class InputIterator, class OutputIterator>
OutputIterator copy(InputIterator first, InputIterator last,
                    OutputIterator result);
//first is the beginning of the first range.
//last is the end of the first range.
//result is the beginning of the second range.

Même si cela peut paraître imposant, en général, vous n'avez pas besoin de spécifier les paramètres du modèle, et peut tout simplement laisser le compilateur gérer pour vous.

std::array<int, 5> arr1 = { 1, 2, 3, 4, 5 };
std::array<int, 5> arr2 = { 6, 7, 8, 9, 0 };
std::string str1 = ".dlrow ,olleH";
std::string str2 = "Overwrite me!";

std::copy(arr1.begin(), arr1.end(), arr2.begin());
//arr2 now stores { 1, 2, 3, 4, 5 }.

std::copy(str1.begin(), str1.end(), str2.begin());
//str2 now stores ".dlrow ,olleH".
//Not really necessary for full string copying, due to std::string.operator=(), but possible nonetheless.

En raison de compter sur les itérateurs, ces fonctions sont également compatibles avec le style C des tableaux (comme les itérateurs sont une généralisation des pointeurs, tous les pointeurs sont, par définition, les itérateurs (mais pas tous les itérateurs sont nécessairement des pointeurs)). Cela peut être utile lorsque vous travaillez avec le code existant, car il permet d'avoir le plein accès à la gamme des fonctions de la bibliothèque standard.

int arr1[5] = { 4, 3, 2, 1, 0 };
std::array<int, 5> arr2;

std::copy(std::begin(arr1), std::end(arr1), std::begin(arr2));

Vous l'avez remarqué dans cet exemple et la dernière que std::array.begin() et std::begin() peut être utilisé de façon interchangeable avec std::array. C'est parce que std::begin() et std::end() sont mis en œuvre tels que, pour tout conteneur, ils ont le même type de retour et retourner la même valeur, que l'appel de la begin() et end() fonctions de membre d'une instance du conteneur.

//Prototype:
template <class Container>
auto begin (Container& cont) -> decltype (cont.begin());

//Examples:
std::array<int, 5> arr;
std::vector<char> vec;

std::begin(arr) == arr.begin();
std::end(arr) == arr.end();

std::begin(vec) == vec.begin();
std::end(vec) == vec.end();

//And so on...

De style C les tableaux n'ont pas de membre de fonctions, ce qui nécessite l'usage de std::begin() et std::end() pour eux. Dans ce cas, les deux fonctions sont surchargés de fournir applicable pointeurs, selon le type de la matrice.

//Prototype:
template <class T, size_t N>
T* begin (T(&arr)[N]);

//Examples:
int arr[5];

std::begin(arr) == &arr[0];
std::end(arr) == &arr[4];

Comme une règle générale, si vous n'êtes pas sûr de savoir si ou de ne pas tout particulier segment de code devrez utiliser le C-style des tableaux, c'est plus sûr d'utiliser std::begin() et std::end().

[Remarque que, bien que j'ai utilisé std::copy() comme un exemple, l'utilisation des plages et des itérateurs est très commun dans la bibliothèque standard. La plupart, si pas tous, fonctions conçu pour fonctionner sur les conteneurs (ou, plus précisément, toute la mise en œuvre de la Concept de conteneurs, comme std::array, std::vector, et std::string) utilisent des plages, de les rendre compatibles avec les actuels et futurs des conteneurs, ainsi qu'avec les C-style de tableaux. Il peut y avoir des exceptions à cette excellente compatibilité que je ne suis pas au courant, cependant.]

2) Lors du passage d'un std::array, en valeur, il peut être fortement les frais généraux, en fonction de la taille de la matrice. En tant que tel, il est généralement préférable de le passer par référence, ou d'utiliser des itérateurs (comme la bibliothèque standard).

//Pass by reference.
const size_t N = 16;

void foo(std::array<int, N>& arr);

3) Tous ces exemples supposent que tous les tableaux dans votre code sera de la même taille, comme indiqué par la constante N. Pour faire plus de votre code plus de la mise en œuvre indépendant, vous pouvez soit utiliser les gammes & itérateurs vous-même, ou si vous voulez garder votre code axé sur les tableaux, l'utilisation basées sur des modèles de fonctions. [Bâtiment sur cette réponse à une autre question.]

template<size_t SZ> void foo(std::array<int, SZ>& arr);

...

std::array<int, 5> arr1;
std::array<int, 10> arr2;

foo(arr1); //Calls foo<5>(arr1).
foo(arr2); //Calls foo<10>(arr2).

Si ce faisant, vous pouvez même aller aussi loin que la modèle de la matrice du type de membre, à condition que votre code peut fonctionner sur d'autres types de int.

template<typename T, size_t SZ>
void foo(std::array<T, SZ>& arr);

...

std::array<int, 5> arr1;
std::array<float, 7> arr2;

foo(arr1); //Calls foo<int, 5>(arr1).
foo(arr2); //Calls foo<float, 7>(arr2).

Pour un exemple de cette action, voir ici.

---

Si quelqu'un voit toutes les erreurs que j'ai peut-être manqué, n'hésitez pas à les signaler pour moi de fixer, ou les corriger vous-même. Je pense que j'ai attrapé tous, mais je ne suis pas sûr à 100%.