İki boyutlu statik array 'a değer atama hakkında

[kahraman1285]

Merhaba

Şu şekilde bir dizim var

Kod: Tümünü seç

var
OnlineUyeler:array [1..100,1..100] of String;

1.bu dizinin elemanlarından herhangibirinde atanmış bir değer olup olmadığını nasıl öğrenebilirim?

2.Bu diziye nasıl değer atayabilirim? Şu şekilde yaptım ama başarılı olamadım

Kod: Tümünü seç

Onlineuyeler[1,1]:=[kullaniciadi,dns_adi];

Bu dizinin her iki boyutundaki elemana tek satırda değer ataması yapamazmıyım?

[aslangeri]

s.a.
1.sorun için döngüye sokarak öğrenebilirsin.
2.dizideki her bir elemana ayrı ayır değer ataman lazım.

Kod: Tümünü seç

online_uyeler:array[3,3]of string;

dediğin zaman bir kitaplık düşün. 3 tane raf var her raf da 3 sütuna bölünmüş. bir rafa komple kitapları alıp yerleştirebilirmisin. aradaki sütunlar ne olacak. onun için tek tek yerleştirmen lazım. (eğer bi kitap yerleştirme makinesi yaparsan olabilir tabi)

Kod: Tümünü seç

online_uyeler[1,1]:='xxxx';
online_uyeler[1,2]:='yyyyyyy';

gibim
kolay gelsin.

[Lost Soul]

Kod: Tümünü seç

 About arrays 
 Arrays are ordered collections of data of one type. Each data item is called an element, and is accessed by its position (index) in the array. They are very useful for storing lists of data, such as customers, or lines of text.
   
 There are a number of types of array, and array may be single or multidimensional (lists of lists in effect).
   
 
Constant arrays 
 It is probably easiest to introduce arrays that are used to hold fixed, unchangeable information. Constant arrays. These can be defined in two kinds of ways:
   
  const
   Days : array[1..7] of string = ('Mon','Tue','Wed','Thu','Fri','Sat','Sun');
 

 
 This first way declares the array as well as the contents in one statement. Alternatively:
   
  type
   TDays = array[1..7] of string;
 const
   Days : TDays = ('Mon','Tue','Wed','Thu','Fri','Sat','Sun');
 

 
 In both cases, we have defined an array of constants that represent the days of the week. We can use them by day number:
   
  const
   Days : array[1..7] of string = ('Mon','Tue','Wed','Thu','Fri','Sat','Sun');
 var
   i : Integer;
 begin
   for i := 1 to 5 do      // Show the weekdays
     ShowMessageFmt('Day %d = %s',[i,Days[i]]);
 end;
 

 
  The ShowMessageFmt routine displays our data - click on it to learn more.
 The data displayed by the above code is:
 
 Day 1 = Mon
 Day 2 = Tue
 Day 3 = Wed
 Day 4 = Thu
 Day 5 = Fri
 

 
 
Different ways of defining array sizes 
 The Days array above was defined with a fixed 1..7 dimension. Such an array is indexable by values 1 to 7. We could have used other ways of defining the index range:
   
 Using enumerations and subranges to define an array size 
 SubRanges are covered in the Enumerations and sets tutorial. Below, we define an enumeration, then a subrange of this enumeration, and define two arrays using these.
   
  type
   TCars  = (Ford, Vauxhall, GM, Nissan, Toyota, Honda);
 var
   cars    : array[TCars] of string;          // Range is 0..5
   japCars : array[Nissan..Honda] of string;  // Range is 3..5
 begin
   // We must use the appropriate enumeration value to index our arrays:
   japCars[Nissan] := 'Bluebird';   // Allowed
   japCars[4]      := 'Corolla';    // Not allowed
   japCars[Ford]   := 'Galaxy';     // Not allowed
 end;
 

 
 Note that the cars array is defined using just a data type - TCars. The size and range of the data type dictates how we use the array. 
   
 Using a data type 
 If we had used Byte as the array size, our array would be the size of a byte - 256 elements - and start with the lowest byte value - 0. We can use any ordinal data type as the definition, but larger ones, such as Word make for large arrays!
   
 
Static arrays 
 There are other ways that arrays vary. Static arrays are the easiest to understand, and have been covered so far. They require the size to be defined as part of the array definition. They are called static because their size is static, and because they use static memory.
   
 
Dynamic arrays 
 Dynamic arrays do not have their size defined in their declaration:
   
  var
   wishes : array of string;     // No size given
 begin
   SetLength(wishes, 3);  // Set the capacity to 3 elements
 end;
 

 
 Here we have defined a wishes array containing string elements. We use the SetLength routine (click on it to find out more) to set the array size. Such arrays are called dynamic because their size is determined dynamically (at run time). The SetLength routine can be used to change the array size more than once - decresaing or increasing the size as desired. My wishes array (list) may indeed grow quite large over time.
   
 Note that we have not given the starting index of the array. This is because we cannot - dynamic arrays always start at index 0.
   
 
Open arrays to routines 
 This is a more specialised use. Open array parameters allow a routine to receive an array of unknown number of dimensions. Delphi silently passes the size to the routine as a hidden parameter. Full example code can be found in Array.
   
 
Multi-dimensional arrays 
 So far, we have only seen lists - single dimensional arrays. Delphi supports arrays of any numbers of dimensions. In reality, a multidimensional array is a collection of arrays - each element of the first array is another array. each element of that array is in turn another array and so on.
   
 It is important to remember this when copying arrays (see below).
   
 Let us define a 2 dimensional array. The code below is a full unit - you can copy and paste this into Delphi, making sure to follow the instructions at the start:
   
  // Full Unit code.
 // -----------------------------------------------------------
 // You must store this code in a unit called Unit1 with a form
 // called Form1 that has an OnCreate event called FormCreate.
  
 unit Unit1;
  
 interface
  
 uses
   SysUtils,
   Forms, Dialogs;
  
 type
   TForm1 = class(TForm)
     procedure FormCreate(Sender: TObject);
   end;
  
 var
   Form1: TForm1;
  
 implementation
 {$R *.dfm} // Include form definitions
  
 procedure TForm1.FormCreate(Sender: TObject);
 var
   // Define dynamic array
   multiArray : Array of Array of byte;  // Multi-dimension array
 
   i,j : Integer;
 
 begin
   // Set the length of the 1st dimension of the multi-dim array
   SetLength(multiArray, 3);
 
   // Set the length of the 3 sub-arrays to different sizes
   SetLength(multiArray[0], 1);
   SetLength(multiArray[1], 2);
   SetLength(multiArray[2], 3);
 
   // Set and show all elements of this array
   for i := 0 to High(multiArray) do
     for j := 0 to High(multiArray[i]) do
     begin
       multiArray[i,j] := i+j;
       ShowMessage('multiArray['+IntToStr(i)+','+IntToStr(j)+'] = '+
                   IntToStr(multiArray[i,j]));
     end;
 end;
 
 end.
 

 
  multiArray[0,0] = 0
 multiArray[1,0] = 1
 multiArray[1,1] = 2
 multiArray[2,0] = 2
 multiArray[2,1] = 3
 multiArray[2,2] = 4
 

 
 There are some important things to note about this code. First, take a look at the IntToStr routine (click on it). Second, that we have defined the size of our multidimensional array piecemeal. SetLength allows us to do this. If we had same sized subarrays, we could have defined the array with one SetLength statement:
   
    SetLength(multiArray, 3, 5);
 

 
 In fact, we can use an array immmediately after defining the first dimension - as long as we restrict ourselves to that dimension.
   
 
Copying arrays 
 When copying single dimension arrays, we can use the Copy routine. It allows us to copy all or part of one array to another, as in this example:
   
  var 
   i : Integer;
   Source, Target : array of Integer;
 
 begin
   SetLength(Source, 8);
 
   for i := 1 to 8 do   // Build the dynamic source array
     Source[i-1] := i;   // Remember that arrays start at index 0
 
   Target := Copy(Source, 3, 4);
 
   for i := 0 to Length(Target) -1 do   // Display the created array
     ShowMessage('Target['+IntToStr(i)+'] : '+IntToStr(Target[i]));
 end;
 

 
  Target[0] : 4
 Target[1] : 5
 Target[2] : 6
 Target[3] : 7
 

 
 Here, we have copied the middle 4 elements of the Source array to a Target array.
   
 When we try to copy a multi-dimensional array, we can still use copy, but it will only copy the First dimension array. Each element in the new array will still refer to the old array subelements. Change one, and the other is changed. This is the cause of many a problem when using complex arrays.