Passer un tableau en argument en C ++

Je suis en train d'écrire une fusion de la fonction de tri, et maintenant je suis juste en utilisant un cas de test array (il n'y a pas d'entrée - c'est statique, pour l'instant). Je ne sais pas comment passer un tableau en argument. Voici mon code maintenant:

//merge sort first attempt

#include <iostream>
#include <algorithm>
#include <vector>

int mergeSort(int[]);
int main()
{
int originalarray[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
mergeSort(originalarray[]);
}

int mergeSort(int[] originalarray)
{
int num = (sizeof(originalarray)/sizeof(int));
std::vector<int> original(num);

if (num > 2) {
    return num;
}

//Fill the array using the elements of originalarray
//This is just for demonstration, normally original will be a parameter,
//so you won't be filling it up with anything.
std::copy(originalarray, originalarray + num, original.begin());

//Create farray and sarray of the appropriate size
std::vector<int> farray(num / 2);
std::vector<int> sarray(num - farray.size());

//Fill those using elements from original
std::copy(original.begin(), original.begin() + farray.size(), farray.begin());
std::copy(original.begin() + farray.size(), original.end(), sarray.begin());

mergeSort(farray);
mergeSort(sarray);

}

Noter que cette mergeSort fonction n'est pas fonctionnel, je n'ai pas compris comment fusionner tout de suite (c'est mon travail). Je voudrais obtenir mon deux vecteurs triés avant de m'occuper de cela, et je ne peux pas compiler ce à cause de mon besoin de passer un tableau en argument. Je ne comprends pas les pointeurs, donc, si c'est la solution, mon excuse, c'est l'ignorance. Je suis en train d'apprendre la programmation en ce moment, avec C++ comme première langue, et ont seulement une connaissance de base de la langue. Merci pour l'aide.

source d'informationauteur jkeys

  1. 17

    Vous ne devez pas utiliser sizeof(originalarray)/sizeof(int) comme ça. Ça ne marchera que pour statiquement déclaré tableaux (la taille est connue à la compilation). Vous devrez passer à la taille. Pourquoi ne pas simplement faire un vector de la matrice et de le transmettre à la place?

    Note de côté: Comme une règle du pouce, toujours noter que sizeof sera traduit au moment de la compilation. Donc il n'y a aucune manière qu'il pourrait connaître la taille du tableau passé en argument.

  2. 30

    Baie vitrée, afin de prolonger un peu, n'oubliez pas que le C++ tableaux sont exactement C des tableaux. Donc, tout ce que vous avez est l'adresse d'un élément de mémoire que prétend (sans garanties) à un tableau de somethings.

    Mise à jour

    Bon, nous allons développer un peu plus.

    C (et, par conséquent, C++) n'a pas vraiment de "tableaux" en tant que tel. Tout ce qu'il a sont des adresses, des pointeurs. Donc, quand vous faites quelque chose d'un "tableau", ce qui se passe vraiment, c'est vous dire au compilateur que certains variable représente une adresse.

    Il est utile de faire une distinction en C entre un déclaration et un définition. Dans une déclaration, vous êtes tout simplement en donnant quelque chose d'un nom et d'un type; dans une définition, vous avez en fait d'allouer de l'espace.

    Donc, si nous commençons par definiing un tableau comme

    int ar[100];

    qui signifie que nous allons dire au compilateur que nous voulons espace pour 100 int's, nous voulons tous être attribués dans un morceau, et nous allons utiliser le nom ar. Le sizeof opérateur donne le nombre d'octets utilisés par un type ou un objet, de sorte que notre tableau ar peut prendre jusqu'à 100×sizeof(int) octets. Sur la plupart des machines, qui sera de 400 octets, mais il varie d'une machine à l'autre.

    Si nous définissons une variable

    int * ar_p;   //using '_p' as a reminder this is a pointer

    nous sommes à la définition de l'espace pour une variable qui contient une adresse. Sa taille sera de sizeof(int*)ce qui sera généralement 4 ou 8, mais sur certaines machines pourrait être n'importe quoi allant de 2 à 16 ans sur certaines machines, vous avez peu de chances de courir à bientôt.

    La nom de la matrice est ar. Le compilateur convertit de ce nom dans une adresse, afin que nous puissions enregistrer cette adresse avec

    ar_p = ar ;     //THIS WORKS

    Maintenant, disons pour la commodité de notre tableau ar qui est arrivé à être en commençant à l'emplacement de 1000 dans la mémoire.

    Ce nom ar ne pas ont aucun espace qui lui est alloué; c'est comme une constante, un certain nombre. Donc, vous ne pouvez pas inverser cette affectation

    ar = ar_p ;     //THIS WON'T WORK

    pour la même raison que vous ne pouvait pas dire

    1000 = ar_p ;   //THIS WON'T WORK EITHER

    c'est à dire, vous ne pouvez pas modifier la valeur de 1000. (Retour dans les premières versions de FORTRAN, cette astuce serait de travailler, pour se complique raisons. C'était une erreur. Vous n'avez jamais vécu jusqu'à ce que vous avez essayé de déboguer un programme dans lequel la valeur de "2" est de 3.)

    Tableaux en C sont toujours basés sur zéro, ce qui est, le premier indice est toujours à zéro. Toutes les autres indices sont juste des adresses calculées à l'aide de l'index. Donc, ar[0] est juste l'adresse 1000 plus de 0 octet d'offset, ou 1000. ar[1] est de 1 000 plus de 1 fois la taille d'un intde sorte que le prochaine int. Et en fait, c'est toujours vrai dans C.

    Il s'agit d'une de référence tableau.

    Lorsque nous utilisons la syntaxe *ar_p nous racontons le compilateur pour obtenir la chose À l'adresse contenue dans ar_p. `.

    Ce qui est appelé déréférencement d'un pointeur de.

    Si nous disons

    ar_p = ar;

    puis *ar_p et ar[0] reportez-vous à la même chose.

    Quand nous disons ar[0] nous racontons le compilateur nous voulons que la chose à l'adresse 0 octets de ar. ar[1] est l'adresse d'un int ou 4 octets, à partir de ar. Donc, *(ar_p+3) fait référence à la même chose que ar[3]. (Nous avons besoin de l'parenthèses parce que nous voulons ajouter 3 à l'adresse en premier et ensuite regarder le contenu. *ar_p+3 serait d'obtenir le contenu pointé par ap_p d'abord, puis ajouter 3.

    La chose est, C ne sait pas, ou beaucoup de soins, quelle est la taille du tableau est vraiment. Si je viens le long et ne ar[365]le compilateur sera heureux de générer du code pour regarder dans la cellule 1000+(365×sizeof(int)). Si c'est dans votre tableau, très bien, mais si c'est juste aléatoire de la mémoire, qui est très bien aussi. C n'a pas de soins.

    (Rappelez-vous, C provient de la compagnie de téléphone. "Nous n'avons pas de soins; nous n'avons pas d'. Nous sommes la Compagnie de Téléphone.")

    Donc, maintenant, nous savons que certaines règles, que j'ai déplacé ici-bas. Lire "≡" comme "est équivalent à" ou "est le même que".

    Ce que vous pouvez compter sur:

    • foo(TYPE t[]) ≡ foo(TYPE * t)

    Depuis C ne sait pas la différence entre les pointeurs et les tableaux, vous pouvez déclarer un ou l'autre. Lorsque vous définissez une fonction, vous pouvez écrire

    void foo(int[] ar){

    ou

    void foo(int* ar){

    et obtenir exactement le même effet.

    • t[i] ≡ *(t+i)

    C'était au-dessus. N'importe où vous pouvez écrire ar[i]vous pouvez le remplacer par *(ar+i). (Il y a effectivement un côté étrange cas que les sauts de cela, mais vous ne pourrez pas l'utiliser en tant que débutant.)

    • où TYPE *t(t+i) sera égale à l'adresse à t plus i*sizeof(TYPE)

    L'a expliqué ci-dessus. Lorsque vous indice dans un tableau, comme ar[42]cela signifie que vous souhaitez que le 42e quel que soit le relais de l'adresse de début. Donc, si vous êtes en utilisant intalors vous avez besoin de déplacer plus de 42 fois cependant, l'ensemble de la int est, qui est-à-dire sizeof(int).

    Maintenant, c'est tout C, et depuis C++ est définie comme une "sorte de" C, c'est tous les détient pour le C++. SAUF

    • sauf TYPE est un type défini par l'utilisateur qui les surcharges operator[] et operator*.

    en C++, vous pouvez décider que vous souhaitez définir un nouveau type qui se comporte comme n'importe quel autre type, mais vous pouvez changer la façon dont la langue n'des choses spécifiques. Ainsi, un programmeur peut décider à la "surcharge" -- c'est à dire remplacer -- le comportement par défaut de la matrice de référence et de déréférencement de pointeur opérateurs avec quelque chose de leur propre conception. Comme un débutant, vous ne devriez pas être confronté à bientôt, mais vous devez être conscients de.

  3. 3

    Je vois que vous incluez <vector>. Je vous suggère de faire disparaître toutes les utilisations de tableaux et d'utiliser uniquement la vector classe. Vous pouvez voir des exemples d'utilisation des conteneurs STL comme vector ici.

  4. 2

    • Lorsque vous passer des tableaux de fonctions, de la décomposition de pointeurs vers le premier élément du tableau, la notation nonobstant. Donc, votre sizeof n'est pas fonctionner comme prévu.

    • Lorsque vous passez dans un tableau, il est préférable de passer à la taille de la matrice, de sorte que vous savez où s'arrêter. Ajouter un paramètre supplémentaire.

  5. 0

    En plus de toutes les réponses ci-dessus, vous pourriez également vouloir vérifier la Q&Comme sur les tableaux de c-faq.com: http://c-faq.com/aryptr/index.html

  6. 0

    Malheureusement, il est très difficile de faire exactement ce que vous voulez faire en C ou C++. Vous pouvez passer un tableau de taille fixe comme ceci:

    int mergeSort(int originalarray[20])
{
    //do something
}

    Cependant, votre taille du tableau n'est pas définie par un nombre, il est défini par le nombre d'éléments dans la liste d'initialisation.

    La chose à faire dans ton cas (même si c'est vraiment une mauvaise chose à faire) est de procéder en deux étapes:

    int originalarray[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
const size_t arraySize = sizeof originalarray / sizeof originalarray[0];
int mergeSort(int array[arraySize])
{
    //do something
}

    Trop mauvais, il ne va pas faire ce que vous devez faire: passage du tableau à une fonction comme ceci rend une copie du tableau, et le point de tri serait de modifier le tableau d'origine.

    En vérité, vous ne pouvez pas aller plus loin sans comprendre le concept de "pointeur".

    La fonction dont vous avez besoin pour développer vraiment devrait être comme ceci:

    int originalarray[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
const size_t arraySize = sizeof originalarray / sizeof originalarray[0];

int mergeSort(int *array, const size_t size)
{
    //do something
}

mergeSort(&(originalArray[0]), arraySize);

    En d'autres termes, vous passez un pointeur vers le premier élément, et le nombre d'éléments.

    Alternativement, vous pouvez traiter avec des vecteurs. Vecteur encapsule les deux mêmes choses (pointeur vers le premier élément et de la taille) en une seule entité appelée "objet". De Plus, il gère la mémoire pour vous, de sorte que vous pouvez étendre le nombre d'éléments que vous le souhaitez. C'est le C++. Dommage que vous ne pouvez pas initialiser un vecteur {...} comme vous pouvez un tableau.

  7. 0

    Dirait que vous êtes en utilisant à la fois des tableaux alloués dynamiquement et vecteurs, quand je crois juste en utilisant std::vector sera suffisant.

    Tout d'abord, laissez votre tableau input être changé pour un std::vector, et le remplir avec vos données d'entrée.

    int main()
{
   std::vector<int> originalarray;
   for (int data = 1; data <= 10; data++)
   {
      originalarray.push_back(data);
   }
   mergeSort(originaldata);
}

    Maintenant, il est important de déclarer votre mergesort fonction pour prendre une référence à un std::vector.

    int mergeSort(std::vector<int>& originalarray)
{
   //The rest of your code, note that now you are passing 
   //in your array for sorting, so you can continue with your code to split
   //the vector into farray and sarray

   //then call sort on your halves.
   mergeSort(farray);
   mergeSort(sarray);

   //I'm guessing at this point you'd write code to combine your farray sarray, and
   //put it back into originalarray...don't forget to clear original array first!
}

    Juste une remarque, on dirait que vous ne faites pas une place de tri, alors attendez-vous à votre sorte de prendre un moment depuis que vous êtes de la copie de beaucoup de données.