Comment gérer différentes tailles de tableau comme arguments pour une fonction?

Il y a plusieurs problèmes dans votre code.

En C ++, un tableau natif (comme votre askin dans main () ) est converti en pointeur lorsqu'il est passé à une fonction. Il n'est donc pas nécessaire de déclarer une dimension sur le tableau dans la liste d'arguments MAIS il est toujours nécessaire de passer un deuxième argument, car vous spécifiez la taille.

Cela signifie que la fonction C ++ doit avoir la forme

#include <vector>

void singlearrayd(const std::vector<double> &temp1, const std::string &str1)
{
    for (std::size_t md_i = 0; md_i < temp1.size(); ++md_i)
   {
        cout << temp1[md_i] << "," << str1 << "(" << md_i << ")";
   }
}

int main()
{
   std::vector<double> askin(21);   // askin has 21 elements, initialised to zero
   std::vector<double> fm(21);
   singlearrayd(askin, "askin");
   singlearrayd(fm, "fm");
}

ou (de manière équivalente)

int main()
{
   double askin[21] = {0.0};   // initialise the first element.  Other elements are initialised to zero
   double fm[21] = {0.0};
   singlearrayd(askin,21,"askin");
   singlearrayd(fm,25,"fm");
}

Notez dans ce qui précède que j'ai spécifié le type du troisième argument par son nom complet comme std :: string . Dans de nombreux cas, il vaut mieux éviter d'utiliser namespace std .

Le deuxième problème est que vous supposez que l'indexation des tableaux Fortran et l'indexation des tableaux C ++ sont identiques. En réalité, l'indexation des tableaux Fortran est basée sur 1 (le premier élément d'un tableau a l'index un, par défaut) et l'indexation des tableaux C ++ est basée sur 0 (le premier élément d'un tableau a un index zéro). L'utilisation de l'indexation de tableau Fortran en C ++ entraîne un comportement indéfini, car elle accédera aux éléments en dehors de la plage valide.

Le troisième problème (potentiel) est que votre fonction définit deux variables nommées md_i (une dans la fonction et une dans la boucle). Il vaut mieux éviter de faire cela.

Le fait de résoudre tout ce qui précède transformera votre fonction en (dans son intégralité)

void singlearrayd(double temp1[], int tempi, std::string str1)
{
    for (int md_i = 0; md_i < tempi; ++md_i)    // note the differences here carefully
    {
        cout << temp1[md_i] << "," << str1 << "(" << md_i << ")";
    }
 }

Le quatrième problème est que main () en C ++ renvoie int , pas void.

Le cinquième problème est que main () n'initialise pas les tableaux avant que singlearrayd () ne les imprime. Dans Fortran, les tableaux locaux à une fonction sont (souvent) initialisés à zéro. En C ++, ils ne sont pas initialisés par défaut, donc accéder à leurs valeurs (par exemple pour les imprimer) donne un comportement indéfini.

void singlearrayd(double *temp1, int tempi, std::string str1)

Cela fera fonctionner votre code. En pratique, cependant, des améliorations sont possibles. La première amélioration consiste à utiliser un conteneur standard plutôt qu'un tableau. Les conteneurs standard connaissent leur taille, ce qui permet de simplifier votre fonction. Deuxièmement, passez des arguments non triviaux (comme des conteneurs ou des chaînes) par référence - et de préférence une référence const si aucune modification n'est apportée à l'argument. Contrairement à Fortran, où les arguments de fonction sont souvent passés par référence PAR DEFAUT, il est nécessaire d'introduire DÉLIBÉRÉMENT des références en C ++.

void singlearrayd(double temp1[], int tempi, std::string str1)

Les conteneurs C ++ prennent également en charge les itérateurs - qui sont plus sûrs en pratique ET souvent plus efficace que l'utilisation de l'indexation de tableau. Je vais vous laisser un exercice pour apprendre à les utiliser.

Un message clé cependant: ne supposez pas qu'une simple traduction mécanique de Fortran vers C ++ fonctionnera. Vous avez déjà démontré les écueils d'une telle hypothèse. Prenez le temps d'apprendre le C ++ AVANT d'essayer de traduire trop de code de Fortran vers C ++. Cela est nécessaire à la fois pour que le code C ++ fonctionne correctement et pour le faire fonctionner efficacement.

Une implémentation plus moderne serait

 #include <string>
 #include <array>
 #include <iostream>

 template <std::size_t size, class U>
 void singlearrayd(const std::array<U, size>& temp1, const std::string& str1){
   int i = 0;
   for (const auto& x : temp1)
      std::cout << x << "," << str1 << "(" << (i++) << ")";
   }

 int main(){
   std::array<double, 21> askin;
   std::array<double, 21> fm; 
   singlearrayd(askin, "askin");
   singlearrayd(fm, "fm");

   return 0;
 }

Veuillez noter que dans le code ci-dessus, les deux tableaux askin et fm ne sont pas initialisés . Vraisemblablement, dans le vrai code, vous les auriez déjà initialisés avant d'appeler singlarrayd . Souvenez-vous également que main doit renvoyer un int.

Merci pour vos précieuses informations et commentaires. Je pense que la meilleure approche a été d'utiliser

    void doublearrayd(double *temp1, int tempi, int tempj, std::string str1){
        for (int md_j = 1; md_j<tempj; md_j++){
            for (int md_i = 1; md_i<tempi; md_i++){
                std::cout << *(temp1 + md_i*tempj + md_j) << "," << str1 << "(" << md_i << ";" << md_j << ")" << std::endl;
            }
        }
    }

    void triplearrayd(double *temp1, int tempi, int tempj, int tempk, std::string str1){
        for (int md_k = 1; md_k < tempk; md_k++){
            for (int md_j = 1; md_j<tempj; md_j++){
                for (int md_i = 1; md_i<tempi; md_i++){
                    std::cout << *(temp1 + md_i*tempj*tempk + md_j*tempk + md_k) << "," << str1 << "(" << md_i << ";" << md_j << ";" << md_k << ")" << std::endl;
                }
            }
        }
    }

En étendant cette idée et en faisant plus de recherches en utilisant Google, j'ai pu étendre cette idée pour gérer les tableaux 2D et 3D.

    void singlearrayd(double *temp1, int tempi, std::string str1)

https://en.wikipedia.org/wiki/Row -and_column-major_order

Comment puis-je transmettre un tableau multidimensionnel dynamique à une fonction?