Incrémenter une variable de type entier dans une boucle

J'en ai "je" qui est une variable de type entier et je voudrais faire une boucle qui incrémente le "je" de 40000 à 90000 ajouter 1000 à chaque fois. Chaque Résultat apparaît dans une liste déroulante.

Exemple: 40000 - 41000 - 42000 - 43000 - ... - 88000 - 89000 - 90000

Mon code est le suivant:

var i:integer;
begin
 for i:= 40000 to 90000 do
  begin
   ComboBox1.AddItem(IntToStr(i), nil); //until here the code works
   Inc(i, 1000);                         
  end;

Avez-vous des suggestions?

Bien que je et nombreux sont ceux qui connaissent la nature de ce type d'erreur que vous obtenez, vous devriez toujours nous dire quel est le message d'erreur.
S'il vous plaît, lire un message d'erreur en entier et de consulter (F1) la documentation de la résolution. Il précise ce que vous ne pouvez pas modifier le compteur de for boucle.

InformationsquelleAutor Alberto Rossi | 2013-05-01

delphi pascal

9

Vous ne pouvez pas modifier la pour la variable de boucle à l'intérieur de la boucle.

Ce que vous voulez, c'est ceci:
```
for i := 0 to 50 do
  ComboBox1.AddItem(IntToStr(40000 + 1000 * i), nil)
```
Mais! C'est plutôt inefficace. Vous devriez envisager de
```
ComboBox1.Items.BeginUpdate;
for i := 0 to 50 do
  ComboBox1.Items.Add(IntToStr(40000 + 1000 * i));
ComboBox1.Items.EndUpdate;
```
- Même si ce n'est le travail, je pense que ce type de boucle cache la logique pour le lecteur. Habituellement, j'essaie de mettre en œuvre cette boucle comme une boucle while comme indiqué par @KenWhite, mais en faisant un pas de plus est de mettre en place une bibliothèque en prenant soin de un pour..l'étape de la boucle. Voir ma réponse, le second serait un gardien dans mes utilitaires.
- J'étais juste sur le point d'ajouter le while option pour ma réponse, mais Ken me battre pour elle. De toute façon, je pense que ça dépend de la "sous-jacent" logique. Parfois, le for boucle pourrait être la plus naturelle. (On pourrait avoir le sentiment que la while appraoch essaie de simuler quelque chose que le programmeur doit vraiment prouver au moment de la conception.)
InformationsquelleAutor Andreas Rejbrand
10

L'alternative à @AndreasRejbrand de la solution est un while boucle:
```
i := 40000;
while i <= 90000 do
begin
  ComboBox1.AddItem(IntToStr(i), nil);
  Inc(i, 1000);
end;
```
ou "repeat":
```
i := 40000;
repeat
  ComboBox1.AddItem(IntToStr(i), nil);
  Inc(i, 1000);
until i > 90000;
```
- +1 mais je pense que l'utilisation d' <= 90000 est un peu moins compliqué pour certaines personnes.
- Je ne recommande pas de l'utiliser à la place; j'ai juste proposé une alternative. Je upvoted Andreas réponse. 🙂
- Je voulais dire, j'aurais utilisé <= 90000 plutôt que < 90001 qui fait la même chose et n'a pas nécessairement de la matière, autres que des raisons de lisibilité
- Oui, vous avez raison. Ce serait plus lisible. Édité pour corriger. Merci.
- Pas vraiment connecté à cette réponse, mais pourquoi tout le monde en utilisant "AddItem" quand le deuxième paramètre est toujours le néant? Pourquoi ne pas utiliser "ajouter" - ComboBox1.Ajouter (IntToStr(i)); ?
- C'est peut-être parce que l'original de l'affiche de l'utilisation AddItem
InformationsquelleAutor Ken White

Le compilateur interdit de modifier la variable de boucle.

Il y a un moyen pour inclure le support pour un for..step boucle.
Vous devez avoir un Delphi version qui prend en charge les génériques (Delphi 2009+).

Viens de faire cette déclaration dans un utilitaire unité:

Type
  ForLoop = record
    class procedure Step( Start,Stop,AStep : Integer; 
                          ALoop : TProc<Integer>); static;
  end;

class procedure ForLoop.Step(Start,Stop,AStep : Integer; ALoop: TProc<Integer>);
begin
  while (start <= stop) do
  begin
    ALoop(start);
    Inc(Start,AStep);
  end;
end;

Et de l'utiliser comme ceci:

ForLoop.Step( 40000,90000,1000,
  procedure ( i : Integer)
  begin
    ComboBox1.AddItem(IntToStr(i), nil);
  end
);

En Delphi 2005, les méthodes sur les enregistrements ont été ajoutées en plus de la for in énumération.

Sachant cela, il est possible de mettre en œuvre une autre boucle for avec un pas de fonctionnalité.

type
  Range = record
  private
    FCurrent,FStop,FStep : Integer;
  public
    constructor Step( Start,Stop,AnIncrement : Integer);
    function GetCurrent : integer; inline;
    function MoveNext : boolean; inline;
    function GetEnumerator : Range; // Return Self as enumerator
    property Current : integer read GetCurrent;
  end;

function Range.GetCurrent: integer;
begin
  Result := FCurrent;
end;

function Range.GetEnumerator: Range;
begin
  Result := Self;
end;

function Range.MoveNext: boolean;
begin
  Inc(FCurrent,FStep);
  Result := (FCurrent <= FStop);
end;

constructor Range.Step(Start,Stop,AnIncrement: Integer); 
begin
  Self.FCurrent := Start-AnIncrement;
  Self.FStop := Stop;
  Self.FStep := AnIncrement;
end;

Et maintenant, vous pouvez écrire :

for i in Range.Step(40000,90000,1000) do
  ComboBox1.AddItem(IntToStr(i), nil);

De creuser dans le fonctionnement interne de cet exemple, voir plus de-plaisir-avec-des agents recenseurs.

Il est facile à mettre en œuvre un .StepReverse version des deux exemples ci-dessus, et je vais laisser cela comme un exercice pour le lecteur intéressé.

InformationsquelleAutor LU RD

Nous pouvons également faire une boucle de 40 à 90 et de multiplier l'indice de 1000

var i: integer;
begin
    for i:= 40 to 90 do
    begin
        ComboBox1.AddItem(IntToStr(i*1000), nil);     
    end;                 
end;

InformationsquelleAutor Nguyễn Phan Hùng Thuận

Vous devez vous connecter pour publier un commentaire.