מערך דו ממדי ב־C++

הקדמה

A two-dimensional array in C++ is the simplest form of a multi-dimensional array. It can be visualized as an array of arrays. The image below depicts a two-dimensional array.

A two-dimensional array is also called a matrix. It can be of any type like integer, character, float, etc. depending on the initialization. In the next section, we are going to discuss how we can initialize 2D arrays.

אתחול מערך דו-ממדי ב־C++

אז, איך אנו מאתחלים מערך דו-ממדי ב־C++? כל כך פשוט:

int arr[4][2] = {
{1234, 56},
{1212, 33},
{1434, 80},
{1312, 78}
} ;

כפי שניתן לראות, אנו מאתחלים מערך דו-ממדי בשם arr, עם 4 שורות ו־2 עמודות כמערך של מערכים. כל איבר במערך הוא שוב מערך של מספרים שלמים.

ניתן גם לאתחל מערך דו-ממדי בדרך הבאה.

int arr[4][2] = {1234, 56, 1212, 33, 1434, 80, 1312, 78};

גם במקרה זה, arr הוא מערך דו-ממדי עם 4 שורות ו־2 עמודות.

הדפסת מערך דו-ממדי ב־C++

סיימנו את תהליך האתחול של מערך דו-ממדי, ואם לא נדפיס אותו, לא נוכל לוודא שהתהליך התבצע כראוי.

בנוסף, במקרים רבים, עשויים להיות צורך להדפיס מערך דו-ממדי תוצאתי לאחר ביצוע פעולות מסוימות עליו. אז איך אנו עושים זאת?

הקוד למטה מראה לנו כיצד ניתן לעשות זאת.

#include<iostream>
using namespace std; 
main( ) 
{  
	int arr[4][2] = {
		{ 10, 11 },
		{ 20, 21 },
		{ 30, 31 },
		{ 40, 41 }
		} ;
		
	int i,j;
	
	cout<<"Printing a 2D Array:\n";
	for(i=0;i<4;i++)
	{
		for(j=0;j<2;j++)
		{
			cout<<"\t"<<arr[i][j];
		}
		cout<<endl;
	}
}

פלט:

בקוד למעלה,

• אנו מאתחלים תחילה מערך דו-ממד, `arr[4][2]`, עם ערכים מסוימים,
• אחרי זאת, אנו מנסים להדפיס את המערך הרצוי באמצעות שני לולאות for,
• הלולאה החיצונית עוברת על השורות, בעוד שהלולאה הפנימית עוברת על העמודות של המערך הדו-ממדי,
• לכל איטרציה של הלולאה החיצונית, `i` עולה ומקדימה אותנו למערך הבא. גם הלולאה הפנימית עוברת על כל המערך ה-1D בתפקיד,
• וכהלכה, אנו מדפיסים את האיבר היחידי `arr[i][j]`.

קבלת איברי מערך דו-ממד כקלט מהמשתמש

כמו שראינו בעבר איך אפשר לאתחל מערך דו-ממד עם ערכים קבועים, ניתן גם לקבוע את הערכים באמצעות קלט מהמשתמש. בואו נראה איךקלט משתמש עשוי להיראות

#include<iostream>
using namespace std; 
main( ) 
{  
      int  s[2][2];
      int  i, j;
      cout<<"\n2D Array Input:\n";
	  for(i=0;i<2;i++)
	  {
	  	for(j=0;j<2;j++)
	  	{
	  		cout<<"\ns["<<i<<"]["<<j<<"]=  ";
	  		cin>>s[i][j];
		}
	  } 
	  
	  cout<<"\nThe 2-D Array is:\n";
      for(i=0;i<2;i++)
	  {
	  	for(j=0;j<2;j++)
	  	{
	  		cout<<"\t"<<s[i][j];
		}
		cout<<endl;
	  } 
} 

פלט:

בקוד למעלה, אנו מכריחים מערך דו-ממד `s` בגודל `2X2`. באמצעות שני לולאות מקוננות אנו עוברים דרך כל איבר במערך וקולטים מהמשתמש את הקלט התואם. כך, המערך מתמלא ואנו מדפיסים את התוצאות.

חיבור מטריצות באמצעות מערכים דו-ממדיים בשפת C++

כדי לדמות, נראה כיצד נוכל להשתמש במערכות דו-ממדיות כדי לבצע חיבור מטריצות ולהדפיס את התוצאה.

#include<iostream>
using namespace std; 
main() 
{  
      int  m1[5][5], m2[5][5], m3[5][5];
      int  i, j, r, c;
      
      cout<<"Enter the no.of rows of the matrices to be added(max 5):";
      cin>>r;
      cout<<"Enter the no.of columns of the matrices to be added(max 5):";
      cin>>c;
      
      cout<<"\n1st Matrix Input:\n";
	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		cout<<"\nmatrix1["<<i<<"]["<<j<<"]=  ";
	  		cin>>m1[i][j];
		}
	  } 
	  
	  cout<<"\n2nd Matrix Input:\n";
	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		cout<<"\nmatrix2["<<i<<"]["<<j<<"]=  ";
	  		cin>>m2[i][j];
		}
	  } 
	  
	  cout<<"\nAdding Matrices...\n";
	  
	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		m3[i][j]=m1[i][j]+m2[i][j];
		}
	  } 
	  
	  cout<<"\nThe resultant Matrix is:\n";

	  for(i=0;i<r;i++)
	  {
	  	for(j=0;j<c;j++)
	  	{
	  		cout<<"\t"<<m3[i][j];
		}
		cout<<endl;
	  } 
	  
} 

פלט:

כאן,

• אנו לוקחים שתי מטריצות m1 ו-m2 עם מקסימום של 5 שורות ו-5 עמודות. ומטריצה נוספת m3 בה נצפה לאחסן את התוצאה,
• כקלט מהמשתמש, לקחנו את מספר השורות והעמודות לשני המטריצות. מכיוון שאנו בוצעים חיבור מטריצות, מספר השורות והעמודות צריכים להיות זהים לשני המטריצות,
• אחרי זאת, אנו לוקחים את שתי המטריצות כקלט מהמשתמש, שוב באמצעות לולאות מקוננות,
• בנקודה זו, יש לנו שתי המטריצות m1 ו-m2,
• אז אנו עוברים דרך המטריצה m3, באמצעות שתי לולאות for ומעדכנים את האלמנטים המתאימים m3[i][j] לפי הערך של m1[i][j]+m2[i][j]. בזה האופן, עם סיום הלולאה החיצונית, אנו מקבלים את המטריצה הרצויה שלנו,
• לבסוף, אנו מדפיסים את המטריצה התוצאה m3.

מצביע למערך דו-ממדי ב-C++

אם יש לנו אפשרות להכיל מצביע למספר שלם, מצביע לשבר, מצביע לתו, האם לא נוכל להכיל מצביע למערך? בהחלט שיש. התוכנית הבאה מראה כיצד לבנות ולהשתמש בו.

#include<iostream>
using namespace std;
/* שימוש במצביע למערך */ 
main( ) 
{  
      int  s[5][2] = {
           {1, 2},
           {1, 2},
           {1, 2},
           {1, 2}
           } ;
           
      int (*p)[2] ;
      int  i, j;
      for (i = 0 ; i <= 3 ; i++)
      {
      		p=&s[i];
      		cout<<"Row"<<i<<":";
            for (j = 0; j <= 1; j++)
                cout<<"\t"<<*(*p+j);
            cout<<endl;
      } 
      
}

פלט:

כאן,

• בקוד לעיל, אנו מנסים להדפיס מערך דו-ממד באמצעות מצביעים,
• כפי שעשינו בעבר, בתחילה אנו מאתחלים את המערך דו-ממד, s[5][2]. וגם מצביע (*p)[2], שבו p הוא מצביע השומר על כתובת של מערך עם 2 אלמנטים,
• כפי שאמרנו כבר, אנו יכולים לפרק מערך דו-ממד כמערך של מערכים. לכן במקרה זה, s בעצם מערך עם 5 אלמנטים, שכל אחד מהם בעצם מערך עם 2 אלמנטים לכל שורה.
• אנו משתמשים בלולאת for כדי לעבור על אלה 5 אלמנטים של המערך, s. בכל איטרציה, אנו משהים את p עם כתובת של s[i],
• לעוד מאוחר עכשיו, הלולאה הפנימית מדפיסה את האלמנטים היחידים של המערך s[i] באמצעות המצביע p. כאן, (*p + j) נותן לנו את הכתובת של האלמנט היחידי s[i][j], כך שבאמצעות *(*p+j) אנו יכולים לגשת לערך המתאים.

מעבר מערך דו-ממד לפונקציה

בסעיף זה, אנו מתכוונים ללמוד איך להעביר מערך דו-ממד לכל פונקציה ולגשת לאלמנטים המתאימים. בקוד למטה, אנו מעבירים את המערך a, לשתי הפונקציות show() ו־print() המדפיסות את המערך הדו-ממד שעבר אליהן.

#include<iostream>
using namespace std;   
 
void show(int (*q)[4], int  row, int  col)
{
	int  i, j ;
	for(i=0;i<row;i++)
	{
		for(j=0;j<col;j++)
    		cout<<"\t"<<*(*(q + i)+j); 
		cout<<"\n";
	}  
    cout<<"\n";
} 
 
void print(int  q[][4], int row, int col)
{
    int  i, j; 
    for(i=0;i<row;i++)
    {   
	 for(j=0;j<col;j++)
   	    	cout<<"\t"<<q[i][j];
   	 cout<<"\n";
	}
   cout<<"\n";
}
 
int main() 
{
  int  a[3][4] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21} ; 
 
  show (a, 3, 4);
  print (a, 3, 4);
  return 0;
} 

פלט:

כאן,

• בפונקצית show() הגדרנו את q להיות מצביע למערך של 4 מספרים שלמים דרך ההצהרה int (*q)[4],
• q holds the base address of the zeroth 1-D array
• כתובת זו מוקצת ל-q, מצביע ל-int, ואז באמצעות זה המצביע נגישים כל הרכיבים של המערך הראשון בשורה.
• בפעם הבאה דרך הלולאה כאשר i לוקחת ערך 1, הביטוי q+i משיג את הכתובת של המערך הראשון. זה כי q הוא מצביע למערך הראשון והוספת 1 אליו תן לנו את הכתובת של המערך הבא. הכתובת הזו מוקצת שוב ל-q ובאמצעותה נגישים כל הרכיבים של המערך הבא
• בפונקציה השנייה print(), ההצהרה של q נראית כך: int q[][4] ,
• זה זהה ל־int (*q )[4], שבו q הוא מצביע למערך של 4 מספרים שלמים. היתרון היחיד הוא שכעת נוכל להשתמש בביטוי המוכר יותר q[i][j] כדי לגשת לרכיבי המערך. יכולנו להשתמש באותו ביטוי ב־show() גם כן אך לצורך הבנה טובה יותר של שימוש במצביעים, אנו משתמשים במצביעים כדי לגשת לכל איבר

מסקנה

כך, במאמר זה דנו ב-מערכים דו-ממדיים בִּשְׂפַת C++, כיצד אפשר לבצע מגוון פעולות שונות וגם אפליקציות שלהן בחיבור מטריצות. לכל שאלה נוספת אתה מוזמן להשתמש בהערות.

הפניות

• https://en.wikipedia.org/wiki/Array_data_structure
• /community/tutorials/arrays-in-c