"Array of const" is een array van variabelen die als constanten worden gedeclareerd. Ze worden rechtstreeks vertegenwoordigd door de TVarRec-structuur. De haakjes bakenen eenvoudigweg de array af. Met een constante array kunt u op een typeveilige manier een variabel aantal parameters aan een procedure doorgeven. Hier is een voorbeeld:

type

TVarRec = record

Gegevens: recordgeval Geheel getal van

0: (L: LangeInt ) ;

1: (B: Booleaans) ;

2: (C: Char) ;

3: (E: ^Uitgebreid) ;

4 : (S: ^tekenreeks) ;

5: (P: wijzer) ;

6: (X: PChar);

7: (O: TObject ) ;

einde ;

Label: Byte;

Stuff: array [ 0 ..2 ] van Byte ;

einde ;

functie PtrToStr(P: Pointer) : string ;

const

HexChar: array [ 0 ..15 ] van Char = "0123456789ABCDEF" ;

functie HexByte(B: Byte ) : string ;

beginnen

Resultaat:= HexChar[ B shr 4 ] + HexChar[ B en 15 ] ;

einde ;

functie HexWord(W: Woord) : string ;

beginnen

Resultaat:= HexByte(Hallo (W) ) + HexByte(Lo (W) ) ;

einde ;

beginnen

Resultaat:= HexWord(HiWord(LongInt (P) ) ) + tray + HexWord(LoWord(LongInt (P) ) ) ;

einde ;

procedure Display(X: array van const );

I: geheel getal;

beginnen

voor I:= 0 tot Hoog (X) doen

met TVarRec(X[I] ) , Gegevens wel

beginnen

geval Tag van

0: ShowMessage("Geheel getal: " + IntToStr (L) ) ;

1: als B dan

ShowMessage("Boolean: True")

anders

ShowMessage("Boolean: False" );

2: ShowMessage("Char: " + C) ;

3: ShowMessage("Float: " + FloatToStr (E^) ) ;

4: ShowMessage("String: " + S^) ;

5: ShowMessage("Aanwijzer: " + PtrToStr(P) ) ;

6: ShowMessage("PChar: " + StrPas (X) ) ;

7: ShowMessage("Object: " + O.ClassName) ;

einde ;

einde ;

einde ;

procedure TForm1.Button1Click (Afzender: TObject ) ;

P: array [ 0 ..5 ] van Char ;

beginnen

P:= "Hallo" # 0 ;

Weergave([ -12345678 , True , "A" , 1.2345 , "ABC" , Ptr ($ 1234 , $5678 ) , P,

Formulier1] );

einde ;

De array van constanten (array of const) is feitelijk een open array TVarRec (beschrijving van vooraf gedeclareerde Delphi-typen je kunt vinden in elektronisch certificaat). De volgende "pseudocode" in Object Pascal kan als skelet dienen voor verdere ontwikkeling:

procedure AddStuff(const A: array van const ) ;

var i: geheel getal;

beginnen

voor i:= Laag (A) tot Hoog (A) doen

met A[i]do

geval VType van

beginnen

(voeg een natuurlijk getal toe, alle reële formaten

Automatisch omgezet naar uitgebreid)

einde ;

beginnen

(voeg een geheel getal toe, alle gehele formaten

Automatisch casten naar LongInt)

einde ;

beginnen

als VObject dan DArray is

met DArray(VObject) doen

beginnen

(voeg een array van dubbel type toe)

anders als VObject dan IArray is

met IArray(VObject) doen

beginnen

(voeg een array van het gehele type toe)

einde ;

einde ;

einde ; (Geval)

einde ; (dingen toevoegen)

Om te ontvangen aanvullende informatie Zie het hoofdstuk "open arrays" in de online-help.
Ontleend aan Delphi Tips van Valentin Ozerov
Collectie Kuliba

Array van constanten tijdens de uitvoering van applicaties

Auteur: Peter Beneden
... oké, de syntaxis ondersteunt dit niet direct, omdat Array of Const vergelijkbaar is met open arrays, voornamelijk in termen van kenmerken tijdens het compileren. Maar je kunt hier omheen komen onaangenaam moment, tenminste hebben basiskennis hoe een open array wordt geïmplementeerd. Wat we hiervoor nodig hebben: een dynamisch toegewezen array van TVarRec, die uw parameters “accepteert”, en een “alias” (alias) Formaatfuncties, waarmee je met zo'n array kunt werken zonder de compiler te "schelden".

type

(we verklaren het type voor dynamische reeks reeks TVarRecs)

TVarArray = array [ 0 ..High (Word ) div Sizeof (TVarRec) - 1 ] van TVarRec;

PVarArray = ^TVarArray;

(Declareer een aliastype voor de functie Format. Doorgegeven parameters zal hebben

De stapel heeft dezelfde aanroepvolgorde als een normale Format-aanroep)

FormatProxy = functie (const aFormatStr: string ; var aVarRec: TVarRec;

HighIndex: geheel getal: string;

(AddVarRecs kopieert de parameters die in array A zijn doorgegeven naar pRecs^, beginnend

Met pRecs^. highIndex - de hoogst beschikbare pRecs-index, nummer

Gedistribueerde elementen - 1. )

procedure AddVarRecs(pRecs: PVarArray; atIndex, highIndex: geheel getal; const A:

reeks const);

I: geheel getal;

beginnen

als pRecs<>nul dan

voor i:= 0 tot hoog (A) doen

beginnen

als bijIndex<= highIndex then

beginnen

PRecs^[atIndex] := A[i] ;

Inc(atIndex);

einde(Als)

anders

Pauze ;

einde ; (Voor)

einde ; (VarRecs toevoegen)

procedure TScratchMain.SpeedButton2Click (afzender: TObject );

S: touwtje;

Proxy:FormaatProxy;

beginnen

(we verdelen de array voor vier parameters, indices - 0..3)

GetMem(p, 4 * Groottevan(TVarRec));

(parameters toevoegen bij daaropvolgende aanroepen van AddVarRecs)

AddVarRecs(p, 0, 3, [ 12, 0,5, "Patroon" ]);

AddVarRecs(p, 3 , 3 , [ "Test" ] ) ;

(we krijgen formaatbevoegdheden)

@Proxy:= @SysUtils.Format ;

(Oproep met een dynamisch gegenereerde reeks parameters.

Uiteraard kan ook de formatstring worden gegenereerd

En tijdens de uitvoering van het programma. )

S:= Proxy( "Geheel getal: %d, Real: %4.2f, Tekenreeksen: %s, %s", p^[ 0 ], 3 ) ;

(wij tonen het resultaat)

Toon bericht(en) ;

Eindelijk

FreeMem(p, 4 * Groottevan(TVarRec));

einde ;

einde ;

Ik hoop dat je het principe begrijpt. Uiteraard zijn er beperkingen. U kunt numerieke waarden, stringvariabelen en letterlijke waarden doorgeven aan AddVarRecs, maar nooit expressies! In dit geval moet de compiler een tijdelijke string op de stapel aanmaken om het resultaat op te slaan, deze doorgeven aan AddVarRecs (of beter aan het adres in TVarRec), en deze kan ophouden te bestaan ​​of kan op de stapel worden overschreven door andere gegevens als je geeft uiteindelijk een hele array door aan Proxy!
Alleen getest in Delphi 1.0!

In Microsoft Excel kunt u matrices maken die niet in celbereiken zijn opgeslagen. Meestal worden ze gebeld reeksen constanten. In deze les leert u wat constante arrays zijn en hoe u ermee kunt werken in Excel.

Kort over constante arrays

Om een ​​constante array te maken, voert u de elementen ervan in en plaatst u deze tussen accolades. De onderstaande afbeelding toont bijvoorbeeld een array bestaande uit 6 constanten:

Een dergelijke array kan worden gebruikt in Excel-formules. De volgende formule somt bijvoorbeeld de waarden van deze array op:

SOM((1,2,3,4,5,6))

Formules kunnen meerdere arrays tegelijk verwerken. De volgende formule retourneert bijvoorbeeld de maximale waarde die het resultaat is van het toevoegen van twee reeksen constanten:

MAX((1,2,3,4,5,6)+(7,8,9,10,11,12))

Constante arrays kunnen getallen, tekst, booleans en foutwaarden bevatten #N.v.t:

=(12;"Tekst";TRUE;FALSE;#N.v.t.)

Mogelijk hebt u een redelijke vraag: waarom is zo'n array nodig? Ik zal dit als voorbeeld beantwoorden.

Een voorbeeld van het gebruik van een reeks constanten in Excel

In onderstaande figuur zie je een lijst met studenten die bepaalde cijfers hebben behaald:

Onze taak is om de schatting van een numerieke vorm om te zetten in de verbale beschrijving en de overeenkomstige waarden weer te geven in het bereik C2:C7. In dit geval heeft het geen zin om een ​​aparte tabel te maken om de tekstbeschrijving van de beoordelingen op te slaan, dus is het winstgevender om de volgende reeks constanten te maken:

=("";"Onvoldoende.";"Bevredigend.";"Goed";"Uitstekend")

In dit geval bevat het eerste element van de array een lege string, omdat wordt aangenomen dat er geen score van 1 kan zijn.

Dan ziet de formule die het gewenste resultaat retourneert er als volgt uit:

In dit voorbeeld is de functie INDEX retourneert de waarde van een element uit een array van constanten, waarvan de positie wordt gespecificeerd door het rangtelwoord (score).

Deze formule is geen matrixformule, hoewel deze wel een matrix bevat. Druk daarom bij het invoeren gewoon op de toets Binnenkomen.

Natuurlijk kunnen we deze formule naar andere cellen kopiëren en het resultaat krijgen dat we nodig hebben:

Maar het zou slimmer zijn om een ​​matrixformule met meerdere cellen te gebruiken. Het zal er als volgt uitzien:

We kunnen nog verder gaan en de constante array een naam geven. De naam wordt op dezelfde manier toegewezen als een gewone constante, via het dialoogvenster Een naam creëren:

Vergeet niet het gelijkteken in het veld op te nemen Bereik, anders behandelt Excel de array als een teksttekenreeks.

Nu ziet de formule er minder eng uit:

Zoals u kunt zien, kunnen reeksen constanten in sommige gevallen zelfs erg nuttig zijn.

In deze les maakte je dus kennis met arrays van constanten en hun gebruik in Excel. Als u nog meer informatie over arrays wilt, lees dan de volgende artikelen.

Een waardearray (of arrayconstante of constante array) is een verzameling getallen of tekstwaarden die gebruikt kunnen worden in . Arrayconstanten moeten in een specifiek formaat worden ingevoerd, bijvoorbeeld voor getallen (1:2:3:4:5) of voor tekstwaarden ("North": SOUTH: "Oost: West").

In een gewone formule kunt u een verwijzing invoeren naar de cel die de waarde bevat, of naar de waarde zelf, ook wel een constante genoemd. Op soortgelijke wijze kunt u een verwijzing naar een array invoeren, of reeks waarden opgeslagen in cellen (in EXCEL wordt dit help genoemd matrixconstante).Array-constanten moet in een specifiek formaat worden ingevoerd.

Een eendimensionale reeks constanten creëren

Vóór de schepping Reeks constanten Laten we het cellenbereik met reguliere waarden eens nader bekijken (zie voorbeeldbestand)

• naar een reeks cellen A 1: A 5 Voer bijvoorbeeld 5 opeenvolgende cijfers van 1 tot 5 in.

• in een cel B1 voer de formule =A1:A5 in;

• bij selecteren A1:A5 en druk op de toets ;
• we krijgen een bepaald record (1:2:3:4:5), wat een reeks waarden uit het bereik is A1:A5

Deze reeks waarden, zoals , staat tussen accolades; de waarden worden gescheiden door dubbele punten. Als de waarden op een rij werden geplaatst (in een bereik A1:E1 ), en niet in een kolom, dan worden de waarden gescheiden door een puntkomma (1;2;3;4;5).

Laten we creëren matrix constante in een cel B2. Om dit te doen, voert u de uitdrukking =(1:2:3:4:5) in de cel in en klikt u op BINNENKOMEN. Array van waarden staat niet automatisch tussen haakjes, zoals matrixformules na het indrukken CTRL+SHIFT+ENTER. Dit moet handmatig gebeuren. Alleen de eerste waarde van de array wordt in de cel weerspiegeld, d.w.z. 1.

Gebruikelijk reeks waarden ga niet in één cel binnen, omdat in dit geval is het niet mogelijk om individuele waarden te extraheren. Om alle waarden van onze weer te geven reeks waarden u moet 5 cellen in een kolom selecteren (bijvoorbeeld B1:B5 ), voer de uitdrukking =(1:2:3:4:5) in en druk op CTRL+SHIFT+ENTER.

Laten we nu proberen één element van de array te verwijderen, bijvoorbeeld uit een cel B 3 . Wij krijgen een waarschuwing" Je kunt een deel van een array niet wijzigen"is een bepaald type arraybescherming.

Om vervelend typen te voorkomen verticaal Voor een matrix met constanten kunt u de formule =ROW(1:5) gebruiken. Nadat u het naar een lege cel hebt geschreven, selecteert u het in de formulebalk, klikt u op en klikt u vervolgens BINNENKOMEN. Haal een array met constanten op (1:2:3:4:5) . Kopieer de inhoud van de cel naar het klembord ( CTRL+C), selecteer vervolgens het verticale cellenbereik dat overeenkomt met de arraydimensie en plak de inhoud in de actieve cel Klemborden en druk op CTRL+SHIFT+ENTER.

Gebruik de formule om de saaiheid van het invoeren van opeenvolgende getallen voor een horizontale reeks constanten te voorkomen =TRANSP(RIJ(1:5)) of =KOLOM(A:E) . Haal een array met constanten =(1;2;3;4;5) op. De arraywaarden worden gescheiden door puntkomma's.

Een constante array gebruiken

A. Vectorvermenigvuldiging (kolom voor kolom, rij voor rij)
Door te gebruiken matrixformules vermenigvuldig de kolom met waarden ( B 2: B 6 ) op reeks constanten(1:2:3:4:5) en vat het samen. Reeks constanten geschreven in "verticale" vorm met een dubbele punt, d.w.z. vertegenwoordigt ook een kolom. De afmetingen van de kolom en de array moeten overeenkomen.

SOM(B2:B6*(1:2:3:4:5))

Nadat u de formule heeft ingevoerd, moet u klikken CTRL+SHIFT+BINNENKOMEN.

Array-formule zal eerst een elementaire vermenigvuldiging uitvoeren van de waarden uit de kolom en de constanten uit de array. Het equivalent van deze formule is de volgende gewone uitdrukking:

SOM(B2*1;B3*2; B4*3; B5*4; B6*5)

De laatste stap is het toevoegen van de waarden met behulp van de functie SOM().

B. Validatie van waarden
Laten we controleren of de waarde in de cel gelijk is aan A1 een van bepaalde waarden: 4, 6 of 9.

OF(A1=(4,6,9))

Na het invoeren van de formule hoeft u niet te klikken CTRL+SHIFT+ENTER. Deze notatie kan de tijd die nodig is om een ​​formule te maken aanzienlijk verkorten in vergelijking met het gebruik van geneste IF()-functies.

Een array van constanten benoemen

Een reeks constanten kan worden toegewezen. Dit gebeurt meestal met constanten die een groep waarden van hetzelfde type vormen, bijvoorbeeld reeksen met een eindig aantal elementen =(1:2:3) .

Toewijzen reeks constanten naam moet u het volgende doen:

• op het tabblad Formules in de groep Specifieke namen team selecteren Wijs een naam toe.
• In het veld Naam binnenkomen Array123.
• In het veld Bereik binnenkomen reeks constanten(vergeet niet de haakjes handmatig in te voeren), bijvoorbeeld (1:2:3) ;
• Klik op OK.

Laten we bijvoorbeeld zoeken door de formule te schrijven =SOMPRODUCT(GROOTSTE(A1:A10,Matrix123)).

Aangenomen wordt dat dit binnen het bereik ligt A1:A10 er is een lijst met numerieke waarden.

Een tweedimensionale reeks constanten creëren

Om een ​​tweedimensionale reeks constanten te maken, moet u het volgende doen:

• Selecteer een celbereik in uw werkmap met vier kolommen en drie rijen ( A1:D3 ).
• in de actieve cel ( A1), v Formule balk expressie invoeren ={1;2;3;4: 5;6;7;8: 9;10;11;12}
• druk op de sneltoets CTRL+SHIFT+BINNENKOMEN

variabele beschrijvingen(var) geeft de afmetingen en het type componenten aan.

Algemeen beeld van de beschrijving van een (eendimensionale) array:

reeks[<тип_индексов> ] 3Ter herinnering: de vetgedrukte vierkante haak is een vereist syntaxiselement. van<тип_компонент>;

Meestal wordt het als volgt geïnterpreteerd:

reeks[<левая_граница>..<правая_граница>] van<тип_компонент>;

Eendimensionaal ( lineaire) array, bestaande uit maximaal 10 gehele getallen, kan als volgt worden beschreven:

var a1: array van gehele getallen;

Nummering

De nummering van arraycomponenten hoeft niet te beginnen bij 1 of 0; u kunt een array beschrijven die is genummerd met willekeurige gehele getallen. Het is alleen nodig dat het nummer van de laatste component groter is dan het nummer van de eerste:

var a1: array [-5..4] van geheel getal;

In feite kunt u de componenten van een array niet alleen met gehele getallen nummeren. Elk ordinaal gegevenstype (opgesomd, interval, teken, logisch, evenals een willekeurig type dat op basis daarvan is gemaakt) heeft het recht om als teller te fungeren. De volgende arraybeschrijvingen zijn dus geldig:

typ char = "a", "c".."z";

(- ontbrekend teken "b") var a1: array van gehele getallen;

- 256 componenten

a2: array van gehele getallen;

- 256 hele componenten

a3: reeks echte;

- 256 echte componenten De totale grootte van de array mag niet groter zijn dan 65.520 bytes. Probeer daarom de array in te stellen op a4:arrayof byte ; zal mislukken omdat het integer-type 65.535 verschillende elementen omvat. En in dit geval is het beter om het longint-type helemaal niet te onthouden.

Het array-componenttype kan van alles zijn:

var a4: array van echt;- een reeks eenvoudige componenten

a5: array van record1;

- reeks 4Sm-records. lezing 7. - a6: array[-10..10] van ^string;- een reeks van 5 cm-wijzers. lezing 12. over lijnen

a7: array[-1..1] van bestand; - een array met namen van bestandsvariabelen 6Sm. lezing 6. a8: array van array van char;

tweedimensionale array - a6: array[-10..10] van ^string;(array van vectoren)

Voor de beknoptheid en het gemak multidimensionale arrays

De algemene beperking op de arraygrootte – niet meer dan 65.520 bytes – geldt ook voor multidimensionale arrays. Het aantal componenten van een multidimensionale array wordt berekend als het product van al zijn “dimensies”. De a9-array bevat dus 200 componenten en de a10-array bevat 32.256 componenten.

Beschrijving van variabele afmetingen

Als uw programma 7 matrices moet verwerken Een matrix is ​​een tweedimensionale tabel bestaande uit getallen. variabele afmetingen (bijvoorbeeld N horizontaal en M verticaal), dan zul je het probleem tegenkomen van het in eerste instantie definiëren van de array, omdat het gebruik van variabelen niet is toegestaan ​​in de var-sectie. Daarom lijkt de meest logische optie

var m,n: geheel getal;

a: reeks echte;

zal moeten worden weggegooid.

Als er in de fase van het schrijven van het programma niets kan worden gezegd over de verwachte omvang van de invoergegevens, dan zit er niets anders op dan de dynamisch toegewezen geheugentechniek te gebruiken (zie lezing 10).

Laten we er echter van uitgaan dat u de maximale grenzen kent waarbinnen de indices van de array die wordt verwerkt, kunnen vallen. Laten we zeggen dat N en M uiteraard niet groter kunnen zijn dan 100. Dan kun je ruimte toewijzen aan de grootst mogelijke array, en eigenlijk maar met een klein deel ervan werken:

const nnn=100; var a: reeks echte;

m,n: geheel getal;

Toegang tot arraycomponenten Arrays zijn directe toegangsstructuren. Dit betekent dat het mogelijk is om direct (zonder eerst alle voorgaande componenten te doorlopen) toegang te krijgen tot elke arraycomponent die ons interesseert. :

<имя_массива>[<индекс_компоненты>]

De componenten van een lineaire array zijn als volgt toegankelijk: 8

<имя_массива>[<индекс>,_,<индекс>]

Vetgedrukte vierkante haken zijn een vereist syntaxiselement. en multidimensionaal - zoals dit: Gebruiksregels

1. indexen
2. bij toegang tot de arraycomponenten zijn:
3. De index van een component kan een constante, een variabele of een expressie zijn die bewerkingen en functieaanroepen omvat.