Comment initialiser un tableau C++

Comment initialiser un tableau en C++ : 1. Définissez d'abord le tableau, puis attribuez une valeur au tableau. La syntaxe est "nom du tableau de type de données [longueur] ; nom du tableau [indice] = valeur ; » ; le tableau lors de la définition du tableau. La syntaxe est "nom du tableau de type de données [longueur] = [liste de valeurs]".

L'environnement d'exploitation de ce tutoriel : système Windows 7, version C++17, ordinateur Dell G3.

Parfois, il est plus approprié de définir la valeur de la variable dans le programme que de saisir la valeur de la variable. Cependant, écrire des instructions d'affectation distinctes pour chaque élément du tableau peut nécessiter beaucoup de saisie, en particulier pour les grands tableaux.

Par exemple, jetez un œil à un programme :

#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    const int NUM_MONTHS = 12;
    int days[NUM_MONTHS];
    days[0] = 31; // January
    days[1] = 28; // February
    days[2] = 31; // March
    days[3] = 30; // April
    days[4] = 31; // May
    days[5] = 30; // June
    days[6] = 31; // July
    days[7] = 31; // August
    days[8] = 30; // September
    days[9] = 31; // October
    days[10] = 30; // November
    days[11] = 31; // December
    for (int month = 0; month < NUM_MONTHS; month++)
    {
        cout << "Month "<< setw (2) << (month+1) << " has ";
        cout << days[month] << " days.\n";
    }
    return 0;
}

Sortie du programme :

Month  1 has 31 days.
Month  2 has 28 days.
Month  3 has 31 days.
Month  4 has 30 days.
Month  5 has 31 days.
Month  6 has 30 days.
Month  7 has 31 days.
Month  8 has 31 days.
Month  9 has 30 days.
Month 10 has 31 days.
Month 11 has 30 days.
Month 12 has 31 days.

Heureusement, il existe une option, le C++ permet d'initialiser les tableaux lors de leur définition. En utilisant une liste d'initialisation, vous pouvez facilement initialiser tous les éléments d'un tableau lorsque vous le créez. L'instruction suivante définit le tableau jours et l'initialise avec les mêmes valeurs établies par l'ensemble des instructions d'affectation du programme précédent :

int days [NUM_MONTHS] = {31，28，31，30，31，30，31，31，30，31，30, 31};

Les valeurs sont stockées dans les éléments du tableau dans l'ordre dans lequel elles apparaissent dans la liste ( la première valeur 31 est stockée en jours[0] , la deuxième valeur 28 est stockée en jours[1] , etc.). La figure suivante montre le contenu du tableau après initialisation.

Le programme suivant est une version modifiée du programme ci-dessus. Il initialise le tableau jours lors de sa création, plutôt que d'utiliser une instruction d'affectation distincte. Notez que la liste d'initialisation est répartie sur plusieurs lignes. Le programme ajoute également un tableau d'objets chaîne pour contenir les noms de mois :

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
int main()
{
    const int NUM_MONTHS = 12;
    string name[NUM_MONTHS]={ "January", "February", "March", "April", "May" , "June", "July", "August", "September", "october", "November", "December"};
    int days[NUM_MONTHS] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    for (int month = 0; month < NUM_MONTHS; month++)
    {
        cout << setw(9) << left << name[month] << " has ";
        cout << days [month] << " days. \n";
    }
    return 0;
}

Sortie du programme :

January   has 31 days.
February  has 28 days.
March     has 31 days.
April     has 30 days.
May       has 31 days.
June      has 30 days.
July      has 31 days.
August    has 31 days.
September has 30 days.
october   has 31 days.
November  has 30 days.
December  has 31 days.

Jusqu'à présent, vous avez montré comment remplir le tableau avec des valeurs numériques, puis afficher toutes les valeurs. Cependant, des fonctionnalités supplémentaires peuvent parfois être nécessaires, comme la récupération d'une valeur spécifique à partir d'un tableau. Le programme suivant est une variante du programme ci-dessus qui affiche le nombre de jours dans un mois sélectionné par l'utilisateur.

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
int main()
{
    const int NUM_MONTHS = 12;
    int choice;
    string name[NUM_MONTHS]={ "January", "February", "March", "April", "May" , "June", "July", "August", "September", "october", "November", "December"};
    int days[NUM_MONTHS] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    cout << "This program will tell you how many days are "<< "in any month.\n\n";
    // Display the months
    for (int month = 1; month <= NUM_MONTHS; month++)
        cout << setw (2) << month << " " << name [month-1] << endl;
    cout << "\nEnter the number of the month you want: ";
    cin >> choice;
    // Use the choice the user entered to get the name of
    // the month and its number of days from the arrays.
    cout << "The month of " << name [choice-1] << " has " << days[choice-1] << " days.\n";
    return 0;
}

Le résultat du programme est :

This program will tell you how many days are in any month.

1 January
2 February
3 March
4 April
5 May
6 June
7 July
8 August
9 September
10 october
11 November
12 December

Enter the number of the month you want: 4
The month of April has 30 days.

Commencer à partir de l'élément de tableau 1

Il y a un grand nombre de choses qui commencent logiquement par 1 dans le monde réel. Lors de la construction de modèles pour de telles choses, beaucoup. les enseignants préféreront que Yu demande aux élèves de ne pas utiliser l'élément 0 mais de stocker les données réelles à partir de l'élément 1. Le nombre de mois dans l'année en est un bon exemple. Dans ce cas, vous pouvez déclarer les tableaux name et day comme ayant 13 éléments chacun et les initialiser comme suit :

string name[NUM_MONTHS+1]={" ", "January", "February", "March", "April", "May" , "June", "July", "August", "September", "october", "November", "December"};
int days[NUM_MONTHS+1] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

Notez que l'élément de tableau 0 n'est pas utilisé. C'est juste une valeur virtuelle. Cela stockera le nom de janvier dans nom[1], le nom de février dans nom[2], et ainsi de suite. De même, le nombre de jours en janvier sera stocké dans l'élément jours[1], le nombre de jours en février dans l'élément jours[2], et ainsi de suite.

Si la méthode ci-dessus est utilisée pour définir et initialiser le tableau, la boucle doit être réécrite sous la forme suivante. Il affichera le contenu des éléments du tableau 1 à 12 au lieu des éléments 0 à 11 comme auparavant.

for (int month = 1; month <= NUM_MONTHS; month++)
{
    cout << setw(9) << left << name[month] << " has ";
    cout << days[month] << " days.\n";
}

Si les données réelles sont stockées en commençant par l'élément 1, il n'est pas nécessaire d'ajouter 1 à l'indice du tableau pour localiser des données spécifiques. Ce qui suit est une modification de la déclaration qui répertorie le numéro et le nom de chaque mois :

for (int month = 1; month <= NUM_MONTHS; month++)
    cout << setw (2) << month << " " << name [month] << endl;

Le code qui affiche le nombre de jours dans le mois sélectionné par l'utilisateur doit être modifié comme suit.

cout << "The month of " << name[choice] << " has "<< days [choice] << " days . \n";

Initialisation partielle du tableau

Lorsqu'un tableau est initialisé, C++ n'a pas besoin d'obtenir la valeur de chaque élément, et ne peut également initialiser qu'une partie du tableau, comme indiqué ci-dessous :

int numbers[7] = {1, 2, 4, 8};

Cette définition initialise uniquement Les 4 premiers éléments d'un tableau de 7 éléments sont illustrés dans la figure ci-dessous.

Figure 2

Il convient de mentionner que les éléments non initialisés de la figure 2 seront tous mis à zéro. C'est ce qui se produit lorsque le tableau numérique est partiellement initialisé. Lorsqu'un tableau d'objets chaîne est partiellement initialisé, les éléments non initialisés contiendront tous des chaînes vides, c'est-à-dire des chaînes de longueur 0. Cela est vrai même si le tableau partiellement initialisé est défini localement. Cependant, si un tableau local n'est pas du tout initialisé, ses éléments contiendront des "déchets", tout comme les autres variables locales.

Le programme suivant affiche le contenu du tableau de nombres après une initialisation partielle :

#include <iostream>
using namespace std;
int main ()
{
    const int SIZE = 7;
    int numbers[SIZE] = {1, 2, 4, 8}; // Initialize the first 4 elements
    cout << "Here are the contents of the array: \n";
    for (int index = 0; index < SIZE; index++)
    cout << numbers [index] << " ";
    cout << endl;
    return 0;
}

Sortie du programme :

Here are the contents of the array:
1 2 4 8 0 0 0

Bien que la liste d'initialisation du tableau puisse avoir moins de valeurs que les éléments du tableau, il n'est pas permis d'en avoir plus que les éléments de la valeur du tableau. L'instruction suivante est illégale car le tableau de nombres ne peut contenir que 7 valeurs, mais la liste d'initialisation contient 8 valeurs.

int numbers [7] = {1, 2, 4, 8, 3, 5, 7, 9};    //不合法

De plus, si un élément n'est pas initialisé, alors tous les éléments après cet élément doivent être laissés non initialisés. C++ ne permet pas d'ignorer des éléments dans une liste d'initialisation. Voici un autre exemple illégal :

int numbers [7] = {1, , 4, , 3, 5, 7};    // 不合法

Taille de tableau implicite

可以通过提供一个包含每个元素值的初始化列表来定义一个数组而不指定它的大小。C++ 会计算初始化列表中的项目数，并为数组提供相应数量的元素。例如，以下定义创建 了一个包含5个元素的数组：

double ratings [] = {1.0,1.5,2.0,2.5,3.0};

注意，如果省略大小声明符，则必须指定一个初始化列表。否则，C++ 不知道该数组有多大。

初始化变量的新方法

到目前为止，已经介绍过的定义和初始化常规变量的方法是使用赋值语句，示例如下：

int value = 5；

但是，我们已经学习过使用函数、数组以及类，所以现在是时候来介绍另外两种在定义变量的同时即进行初始化的方法。

第一种新方法是使用函数符号初始化变量。它看起来就像是给一个函数传递参数。如果您已经掌握了类的内容，那么就会注意到，它也很像是在创建类对象时给一个构造函数传递值。以下是使用函数符号定义变量 value 并初始化其值为 5 的示例语句：

int value (5);

第二种初始化变量的新方法是 C++ 11 中新引入的，使用大括号表示法。它看起来就像是刚刚上面所看到的初始化数组的方法，但是其中有两点区别：

• 因为常规变量只能一次保存一个值，所以通过这种方法初始化变量时，大括号中只有一个值；

• 和数组初始化列表不一样，通过这种方法初始化变量时，在大括号前面没有赋值运算符（=）。

以下是使用大括号表示法定义变量 value 并初始化其值为5的示例语句。

int value{5}; //该语句仅在C++ 11或更高版本中合法

绝大多数程序员会继续使用赋值运算符来初始化常规变量，本书也将如此，但是，大括号表示法提供了一项优点，它会检查用来初始化变量的值，并确保匹配变量的数据类型。例如，假设 doubleVal 是一个 double 类型变量，存储在其中的值为 6.2。则使用赋值运算符时，可以编写以下两种形式的语句之一：

int valuel = 4.9；    //该语句将给valuel赋值为。4
int vaule2 = doubleVal;    // 该语句将给 value2 赋值为 6

在这两种情况下，值的小数点部分都会被先截断，然后才赋值给被定义的变量。这虽然可能会导致一些问题，但 C++ 编译器是允许的，它也会提出警告，但却仍然能生成可执行文件，并且可以运行。不过，如果在这里使用的是大括号表示法，则编译器会指出这些语句产生了一个错误，并且不会生成可执行文件。必须先修复该错误，然后重新编译项目才能运行该程序。

相关推荐：《C++视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!