ورود

توجه ! این یک نسخه آرشیو شده میباشد و در این حالت شما عکسی را مشاهده نمیکنید برای مشاهده کامل متن و عکسها بر روی لینک مقابل کلیک کنید : دوستانی که علاقه به ++cدارن بفرمایین



uody
7th March 2011, 07:27 PM
سورس برنامه محاسبه nامین عضو سری فیبوناچی (Fibonacci) بصورت تابع بازگشتی در C++

http://www.foxworld.ir/wp-content/uploads/2011/02/fibonacci-sequence.jpg

.سری فیبوناچی(Fibonacci) با عدد صفر و سپس یک شروع میشود و هر عدد بعد از این دو، مجموع دو عدد قبل خواهد بود.

… ,۲۱, ۱۳, ۸, ۵, ۳, ۲, ۱, ۱, ۰

سری فیبوناچی در طبیعت و جاهای دیگر باعث ایجاد اشکال حلزونی و مارپیچ میشود. نسبت اعداد فیبوناچی به یکدیگر حدود ۱٫۶۱۸ میباشد که به عنوان یک عدد طلایی در طبیعت در نظر گرفته شده است. انسان همواره سعی کرده که در طراحی ها، ساختمان ها، اتاق ها، پنجره ها و … این نسبت طلایی را را رعایت کند.

int f ( int x)
{
if ((x==1)||(x==2))
return 1;
else if (x==0)
return 0;
else
return f(x-1)+f(x-2);
}

//end

uody
7th March 2011, 07:29 PM
تابع مرتب سازی سطلی یا صندوقی(Bucket Sort) در C++

http://www.foxworld.ir/wp-content/uploads/2011/02/Bucket_sort_1.png

مرتب سازی سطلی یا مرتب سازی صندوقی ، نوعی الگوریتم مرتب سازی است که با تقسیم کردن یک آرایه به تعدادی سطل کار می‌کند. سپس هر سطل به طور جداگانه مرتب می‌شود که این کار مرتب کردن می‌تواند از یک الگوریتم مرتب سازی دیگر استفاده کرده یا مرتب سازی سطلی را به طور بازگشتی روی آن اجرا کند. مرتب سازی سطلی تعمیم مرتب سازی لانه کبوتری است. از آن جایی که این مرتب سازی ، مرتب سازی مقایسه ای نیست ،(Ω(nlog n به عنوان حد پایین برای آن غیر قابل اجرا می‌باشد. پیچیدگی محاسباتی برای آن بر اساس تعداد سطل‌ها محاسبه می‌شود.

void bucketSort(int a[],int n, int max)
{
int* buckets = new int[max];
int SIZE = n;
for(int j = 0 ; j <= max ; j++)
buckets[j] = 0;
for(int i = 0 ; i < SIZE ; i++)
++buckets[a[i]];
for(i = 0 , j = 0 ; j <= max ; ++j)
for(int k = buckets[j] ; k > 0 ; k--)
a[i++] = j;
}

//end

uody
7th March 2011, 07:31 PM
الگوریتم مرتب سازی ادغامی(Merge Sort) در C++

http://www.foxworld.ir/wp-content/uploads/2011/02/Merge_sort_animation2.gif

مرتب سازی ادغامی، حل مسئله را به چند قسمت تبدیل کرده و آن ها را جدا حل میکند. به همین سبب از چندین تابع برخوردار است و متوسط عملکرد آن از رابطه O(n log n) بدست می آید. سورس این الگوریتم در ادامه مطلب قرار داده شده است . دوستان نظر یادتون نره.

void mergeSort(int numbers[], int temp[], int array_size)
{
m_sort(numbers, temp, 0, array_size - 1);
}

void m_sort(int numbers[], int temp[], int left, int right)
{
int mid;

if (right > left)
{
mid = (right + left) / 2;
m_sort(numbers, temp, left, mid);
m_sort(numbers, temp, (mid+1), right);

merge(numbers, temp, left, (mid+1), right);
}
}

void merge(int numbers[], int temp[], int left, int mid, int right)
{
int i, left_end, num_elements, tmp_pos;

left_end = (mid - 1);
tmp_pos = left;
num_elements = (right - left + 1);

while ((left <= left_end) && (mid <= right))
{
if (numbers[left] <= numbers[mid])
{
temp[tmp_pos] = numbers[left];
tmp_pos += 1;
left += 1;
}
else
{
temp[tmp_pos] = numbers[mid];
tmp_pos += 1;
mid += 1;
}
}

while (left <= left_end)
{
temp[tmp_pos] = numbers[left];
left += 1;
tmp_pos += 1;
}
while (mid <= right)
{
temp[tmp_pos] = numbers[mid];
mid += 1;
tmp_pos += 1;
}

//modified
for (i=0; i < num_elements; i++)
{
numbers[right] = temp[right];
right -= 1;
}
}

//end

uody
7th March 2011, 07:33 PM
سورس تعیین مثلثی بودن ماتریس C++

http://www.foxworld.ir/wp-content/uploads/2011/01/down.jpg
این برنامه با گرفتن یک ماتریس، مثلثی بودن یا نبودن آن را محاسبه و نمایش میدهد.در ادامه مطلب می توانید سورس این برنامه را مشاهده کنید.

#include
#include

int Matrix(int** matrix,int size)
{
int down=0,up=0;
for(int i=0;ii && matrix[i][j] != 0)
down=2;
if(i>j && matrix[i][j] != 0)
up=1;
}
}
return down+up;
}

int main()
{
int size=0;
cout<<"Enter size of matrix(number of rows and columns):";
cin>>size;
cout<>matrix[row-1][i];
row++;
}
for(i=0;i

uody
7th March 2011, 07:35 PM
تابع مرتب سازی انتخابی(Selection Sort) در C++

http://www.foxworld.ir/wp-content/uploads/2011/01/Selection_sort_animation.gif

void selectionSort(int arr[], int len)
{
int i, j, minIndex, tmp;
for (i = 0; i < len - 1; i++)
{
minIndex = i;
for (j = i + 1; j < len; j++)
if (arr[j] < arr[minIndex])
minIndex = j;
if (minIndex != i)
{
tmp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = tmp;

}

}

}

uody
7th March 2011, 07:37 PM
تابع مرتب سازی سریع(Quick Sort) در C++


http://www.foxworld.ir/wp-content/uploads/2011/01/Sorting_quicksort_anim.gif

تابع مرتب سازی سریع(Quick Sort) که متوسط عملکرد آن O(n log n) در ادامه مطلب می توانید سورس را مشاهده کنید.




void quickSort(int x[], int left, int right)
{

int i = left, j = right;

int tmp;

int pivot = x[(left + right) / 2];

while (i <= j)
{

while (x[i] < pivot)

i++;

while (x[j] > pivot)

j--;

if (i <= j)
{

tmp = x[i];

x[i] = x[j];

x[j] = tmp;

i++;

j--;

}

}

if (left < j)

quickSort(x, left, j);

if (i < right)

quickSort(x, i, right);

}

//end

uody
7th March 2011, 07:39 PM
سورس اجتماع و اشتراک دو مجموعه مرتب شده در C++


http://www.foxworld.ir/wp-content/uploads/2011/01/cplusplus.jpg

این برنامه دو لیست مرتب شده از ورودی گرفته و اشتراک و اجتماع آنها را محاسبه و چاپ میکند.

#include

void main()
{
int n, m, x[50], y[50];
register c;
cout<<"Enter the number of first list's elements:";
cin>>n;
cout<<"Enter the first sorted list:"<>x[i];
cout<<"Now enter the number of second list's elements:";
cin>>m;
cout<<"Enter the second sorted list:"<>y[c];
//------------------------------------------------------------
cout<<"Union: ";
char ch;
i=0;
for( i=0;i

uody
7th March 2011, 07:42 PM
تابع مرتب سازی درجی(Insertion Sort) در C++


http://www.foxworld.ir/wp-content/uploads/2011/02/Insertion_sort_animation.gif

[COLOR="Black"]مرتب‌ساز درجی (Insertion Sort) یک الگوریتم مرتب‌سازی ساده بر مبنای مقایسه است. این الگوریتم برای تعداد داده‌های زیاد، کارآمد نیست و در این موارد، الگوریتم‌های بهتری مثل مرتب‌ساز سریع، مرتب‌ساز ادغامی و مرتب‌ساز پشته وجود دارد.
این الگوریتم به این صورت عمل می‌کند که تمام عناصر لیست را یکی یکی برمی‌دارد و آن را در موقعیت مناسب در بخش مرتب شده قرار می‌دهد. انتخاب عنصر مورد نظر، اختیاری است و می‌تواند توسط هر الگوریتم انتخابی، انتخاب شود. مرتب‌سازی درجی به صورت درجا عمل می‌کند. نتیجه عمل بعد از k مرحله، حاوی k عنصر انتخاب شده به صورت مرتب شده است.

void insertionsort ( int arr[] , int n)
{
int i , j , x;
for (i=2 ; i<=n ; i++)
{
x = arr [i];
j= i-1;
while( j>0 && arr [j] > x)
{
arr[j+1] = arr [j];
j--;
}
arr[j+1]=x;
}
}

//منبع:فاکس ورلد[/

COLOR]end

uody
8th March 2011, 02:07 PM
توابع در ++C:

برنامه ای که به این زبان نوشته میشود، حداقل شامل تابع main است که علاوه بر این میتواند از یک یا چند تابع تعریف شده توسط کاربر استفاده کند.

تعریف تابع:
روش اول:

(لیست آرگومان ها) نام تابع نوع بازگشتی
}
بدنه تابع
{

مثال:

int a(x,y,z)
char x;
int y;
float z;
{
x='a';
}

//end


روش دوم:

(...،آرگومان2 نوع2 ،آرگومان1 نوع 1) نام تابع نوع بازگشتی
}
بدنه تابع
{

مثال:

int b(char x, int y, float z)
{
x='a';
}

//end

تعریف بخش های یک تابع:

1. نوع بازگشتی:

نوع داده ای که قرار است تابع داده ای از آن نوع را به قسمتی که تابع را فراخوانی کرده است، برگرداند. مانند: int, float, double, char, void

نکته: در صورتی که نوع بازگشتی void تعیین شود یا هیچ نوعی قرار نگیرد، تابع هیچ مقداری را بر نمیگرداند و فقط دستورات بدنه را اجرا و از آن خارج میشود.

2. نام تابع:

اسامی انتخاب شده برای توابع باید از قواعد تولید شناسه پیروی کند.

3. لیست آرگومان ها:

میزان، تعداد و نوع مقادیر ورودی یک تابع توسط لیست آرگومان های تابع مشخص میشود.

نکته: اگر تابعی فاقد لیست آرگومان ها باشد، یعنی این تابع ورودی از طریق آرگومان هایش ندارد، لذا باید یا لیست آرگومان ها را خالی بگذاریم و یا اینکه از نوع داده ای void استفاده کنیم.

4. بدنه ی تابع:

بدنه ی تابع قسمتی است که در آن دستورات یک تابع که باید روی مقادیر آرگومان هایش انجام شود، را مینویسیم. در این قسمت نیز همانند داخل تابع main امکان استفاده از تمامی دستورات زبان برنامه نویسی ++C را داریم.

محل تعریف توابع:

1.تعریف تابع و بدنه ی آن قبل از تابع اصلی:


(لیست آرگومان ها) نام تابع نوع تابع
}
بدنه
{
int main()
{
return 0;
}

//end

2. تعریف خطی (معرفی تابع قبل از main و تعریف آن بعد از main):

;(لیست آرگومان ها) نام تابع نوع تابع
int main()
{
return 0;
}
//end
(لیست آرگومان ها) نام تابع نوع تابع
}
بدنه
{
نکته: به دلیل ساختار top to down بودن در ++C، هنگامی که میخواهیم تابع را بعد از تابع اصلی(main) تعریف کنیم باید قبل از تابع اصلی آن را معرفی کنیم.

نکته: هنگام تعریف خطی تابع حتما دقت میکنیم که بعد از پرانتز بسته ی لیست آرگومان ها، گذاشتن ; الزامی است.

نکته: فراخوانی یک تابع، داخل تابع دیگر مجاز است ولی تعریف یک تابع در تابع دیگر مجاز نیست و خطا دارد.

uody
8th March 2011, 02:09 PM
فراخوانی توابع:

برای فراخوانی یک تابع در تابع اصلی، کافیست نام تابع به همراه مقادیر پارامتر های تابع(در صورت وجود) را بنویسیم.

مثال:

#include <iostream.h>
int f(int x, int y)
{
return x*y;
}
void main()
{
int a,b;
cout<<"Enter 2 numbers:"<<endl;
cin>>a>>b;
cout<<"\nResult: "<<f(a,b);
}

//end

نعریف پارامتر:

به مقادیر یا متغیر هایی که هنگام فراخوانی یک تابع، جایگزین آرگومان های تابع میشوند، پارامتر گویند.
در مثال قبل که f(a,b) را فراخوانی کردیم، مقادیر a,b جایگزین x,y در تابع شدند. یعنی x,y آرگومان های تابع هستند و a,b پارامتر های تابع محسوب میشوند.

نکته: تابع میتواند آرگومان ورودی نداشته باشد که در این صورت میتوان در هنگام تعریف، نوع بازگشتی تابع را از نوع void معرفی کرد یا پرانتز جلوی تابع را خالی گذاشت.

مقدار بازگشتی تابع:

به مقداری که تابع بعد از اتمام عملیات به خود می گیرد، مقدار بازگشتی تابع میگویند که با return مشخص میشود.
در مثال قبل، بعد از کلمه ی return عبارت x*y وجود دارد. یعنی x*y محاسبه شده و مقدار حاصل را در تابع میریزد.

نکته: در صورتی که در یک تابع بیش از یک return وجود داشته باشد، return اول مقدار را بازگشت داده و مابقی دستورات اجرا نمیشوند.

uody
8th March 2011, 02:13 PM
تابع محاسبه فاکتوریل یک عدد بصورت غیر بازگشتی

تابعی غیر بازگشتی که مقدار فاکتوریل یک عدد را به خود میگیرد:


long fact(int x)
{
long y=1;
while(x>=1)
{
y*=x;
x--;
}
return y;
}

end

تابع غیر بازگشتی به توان رساندن یک عدد(شبیه ساز تابع pow)

تابعی که یک عدد و یک توان به عنوان آرگومان ورودی گرفته و مقدار حاصل را بازگشت میدهد:


long power(int x, int y)
{
long z=1;
while(y>0)
{
z*=x;
y--;
}
return z;
}

//end

uody
8th March 2011, 02:17 PM
توابع بازگشتی

همان طور که قبلا ذکر شد، امکان فراخوانی یک تابع در تابع دیگر همواره وجود دارد.
خاصیت مهم اینجاست که در زبان ++c میتوان درون یک تابع، خود تابع را نیز با لیست آرگومانهای جدید فراخوانی کرد.

از خاصیت بالا برای انجام کارهایی که به صورت تکرار محاسبات مراحل قبلی صورت میگیرند، میتوان استفاده نمود.

در توابع بازگشتی، توجه به دو نقطه بسیار مهم است:

1.نقطه بازگشت
نقطه بازگشت جایی است که باید خود تابع با آرگومان لیست جدید فراخوانی شود. یعنی به نقطه ین بست نرسیده ایم.

2.نقطه بن بست
نقطه بن بست جایی است که در آنجا باید روند فراخوانی را که انجام داده ایم، بصورت بازگشت به عقب انجام دهیم تا جواب مطلوب حاصل شود.

مثال: تابع بازگشتی محاسبه ب م م دو عدد

یک تابع بازگشتی برای محاسبه ی ب م م دو عدد به عنوان آرگومان ورودی:


long bmm(int a, int b)
{
if(a<b)
return bmm(b,a);
else if(b==0)
return a;
else
return bmm(b,a%b);
}

//e

uody
8th March 2011, 02:19 PM
توابع inline و قالب های تابع

توابع inline:
اگر یک برنامه به روش ساخت یافته(با استفاده از توابع) پیاده سازی کنیم، از نقطه نظر زمان اجرای برنامه باعث بروز تاخیر به لحاظ فراخوانی یک تابع، اجرای آن و بازگشت به تابع اصلی میشود که سرعت اجرای برنامه را پایین می آورد.
حال اگر یک برنامه کد اجرایی کوتاهی داشته باشد و در تابع اصلی یا توابع دیگر این تابع چندین بار فراخوانی شود، باعث بروز تاخیر زمانی زیادی میشود. لذا برای این گونه توابع که خاصیت گفته شده را دارا میباشند، راهکار تعریف به صورت inline تعریف شده است. بدین صورت که اگر ما در طی برنامه از کلمه کلیدی inline قبل از تعریف تابع استفاده کنیم، این امر موجب میشود که کد تابع در هنگام اجرای برنامه در جایی که تابع فراخوانی میشود کپی شده و دیگر تاخیر زمانی بابت فراخوانی، بازگشت و اجرا نداریم.

قالب های تابع(function template):
در توابع عم نام اگر تعداد آرگومان ها یکسان باشد و بدنه ی اجرایی تابع نیز به یک شکل باشد و فقط توابع در نوع بازگشتی و نوع آرگومانها تفاوت داشته باشند، می توان به جای نوشتن هر تابع از یک قالب تابع استفاده کرد. به شکل زیر و با کلمه ی کلیدی template:


template <class T>
T A ( T1, T2, ...)
{
...
}

//end
در بالا منظور از T هر نوع داده ای(مانند int) و از A نام تابع است. هم چنین T1, T2, ... آرگومان های تابع هستند

uody
14th March 2011, 04:59 PM
امروز چند تا برنامه برا این تاپیک میزارم تا .........[cheshmak]
// بنویسید که دارای تابعی برای دریافت قاعده و ارتفاع مثلث و تابعی برای محاسیه Triangle کلاسی به نام

//مساحت مثلث داشته باشد

#include”iostream.h”

class triangle

{

public:

void input();

void calc();

private:

int h,g,cal;

};

main()

{

triangle x;

x.input();

x.calc();


return 0;

}

void triangle::input()

{

cout<<”Programmer:Hamid jalali \n http://pnu.hamidjalali.com\nenter ertefa and ghaedeh : “;

cin>>h>>g;

}

void triangle::calc()

{

cal =( (0 .5)*(g*h) );

cout<<”cal=”<<cal<<endl;

}

//************************************************** ******************//


//برنامه ای بنویسید که رشته ای را که به نقطه ختم می شود از ورودی خوانده ، کارکترهای موجود در رشته را به همراه تعداد دفعات تکرار آنها به خروجی ببرد//

#include<iostream.h>

#include<conio.h>

#include<string.h>

void Calc( char a[]) ;

int main(){

const int k=100;

char a[k];

clrscr() ;

cout << “Programmer:Hamid jalali \n http://pnu.hamidjalali.com\n“;

cout<<” Enter string : ” ;

cin.get ( a , k , ‘.’) ;

Calc( a ) ;

getch() ;

return 0 ;

}

//************************************************** **********

void Calc( char a[]){

int ar[30];

int i;

char c;

for ( i=0 ; i<30 ; i++ )

ar[i] = 0;

for ( i=0 ; i<strlen(a) ; i++ )

ar[ (a[i] – 97)]++;

for ( i=0 ; i<30 ; i++ )

if (ar[i] != 0)

{

c = i + 97;

cout << c << ” ” << ar[i] << “\n”;

}

//************************************************** ******************//

// را دریافت کرده n برنامه ای بنویسید که ابتدا عدد مثبت و صحیح

// عدد صحیح دریافت کرده به صورت صعودی مرتب کرده و نمایش بدهدn و سپس


#include”iostream.h”

#include”iomanip.h”

int main()

{

int *a;int n;

cout<<”Programmer:Hamid jalali \nhttp://pnu.hamidjalali.com\nEnter number of item: “;

cin>>n;

a=new int[n];

/////////Begin input number///

for(int i=0;i<n;i++)

{

cout<<”no.”<<i+1<<” :”;

cin>>a[i];

}//////////////Begin Bubble sort (Decreacing)/////////////

for(i=n-1;i>0;i–)

for(int j=0;j<i;j++)

if(a[j]>a[j+1])

{

int temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}


/////////////////////////End of sort////////////

cout<<”Sorting list is :”;

for(i=0;i<n;i++)

cout<<a[i]<<setw(6);

cout<<endl;

return 0;

}

//************************************************** ******************//



// برنامه ای بنویسید که رشته ای را از ورودی دریافت کند مشخص کند که متقارن است یا نه

//aabaa,ccbbfbbcc,vvmmvv مثل

#include”iostream.h”

#include”stdlib.h”

int main()

{ const int max=100;

int count=0,j=0;

char a[max];

cout<<”Programmer:Hamid jalali \nhttp://pnu.hamidjalali.com\nEnter string:”;

cin.get(a,max);

for(int i=0;a[i];i++)

count+=1;

for(i=0,j=count-1;i<(count/2),j>(count/2);i++,j–)

if(a[i]==a[j]) continue;

else {cout<<”No motagharen nist \n”;exit(0);}

cout<<”Yes motagharen ast \n”;

return 0;

}

//************************************************** ******************//


را نمایش دهد//nبرنامه ای بنویسید که کلیه مقسوم علیه های عدد صحیح و مثبت

#include”iostream.h”

int main()

{ int n;

cout<<”Programmer:Hamid jalali \nhttp://pnu.hamidjalali.com\nEnter number:”;

cin>>n;

for(int i=2;i<=(n/2);i++)

if(n%i==0) cout<<i<<”, “;

return 0;

}

//************************************************** ******************//

//برنامه ای بنویسید که ۳ عدد تصادفی بین اعداد ۱ تا ۲۰ را تمایش بدهد

#include”iostream.h”

#include”stdlib.h”

int main()

{ cout<<”Programmer:Hamid jalali \nhttp://pnu.hamidjalali.com\n”;

cout<<”This program show 3 random number betwen 1 to 20\n”;

for(int i=1;i<4;i++)

cout<<rand()%20+1<<”\t”;

return 0;

}

//************************************************** ******************//

تایع strcmp

#include”iostream.h”
int strcmp(const char *s1,const char *s2)
{
while(*s1)
if(*s1-*s2)
return *s1-*s2;
else
{ *s1++;
*s2++;
}
return 0;//is equal
}

int main()
{ char str1[80],str2[80];
cout<<”Enter two string:”;
cout<<”string1:”; cin>>str1;
cout<<”string2:”; cin>>str2;
cout<<strcmp(str1,str2);
return 0;

uody
9th April 2011, 07:48 PM
آرایه*ی پویای دو بعدی در ++c

آرایه*های دو بعدی کاربردهای بسیاری از جمله جداول و ماتریس*ها دارند. اهمیت تعریف آرایه*های پویای دو بعدی کمتر از آرایه*های یک بعدی نیست. آرایه*های پویای دو بعدی یک ویژگی جالب در مقایسه با آرایه*ی ایستا دارند: شما با تعریف پویای آرایه*های دو بعدی می*توانید جداول غیرمستطیلی تشکیل بدهید. در واقع وقتی شما آرایه*های دو بعدی را به صورت پویا ایجاد می*کنید، این اختیار را دارید که تعداد ستون*های هر ردیف را متفاوت انتخاب کنید.
به قطعه کد زیر توجه کنید:


int **table;
cin >> n;
table = new int*[ n ];
register int i, j;
for ( i = 1 ; i <= n ; i++ )
{
table[ i - 1 ] = new int[ i ];
for ( j = 1 ; j <= i ; j++ )
{
table[ i - 1 ][ j - 1 ] = i * j;
}
}
.
.
.
for ( i = 0 ; i < n ; i ++ )
{
delete[] table[ i ];
}
delete[] table;

این کد عدد n را از کاربر گرفته و نیمه*ی پایینی جدول ضرب n در n را در یک آرایه*ی پویا ذخیره می*کند. جدول ضرب اعداد متقارن است و نیازی به ذحیره کردن اعداد همه*ی خانه*های جدول نیست. در نتیجه با آرایه*ی پویای دو بعدی حافظه*ی مصرفی تقریبا نصف می*شود.
متغیر table که به صورت table** تعریف شده است، یک اشاره*گر به اشاره*گر است. کامپایلر وقتی با دستور

table = new int*[ n ];

مواجه می*شود، یک آرایه*ی پویای یک بعدی به طول n از اشاره*گرهای صحیح ایجاد می*کند. پس عناصر

table[ 0 ], table[ 1 ], ..., table[ n - 1 ]

هر کدام یک اشاره*گر از نوع صحیح هستند. حال با دستور

table[ i - 1 ] = new int[ i ]

برای هر اشاره*گر یک آرایه*ی پویای یک بعدی منسوب می*کنیم.
مثلا به ازای n = 3 عناصر table به صورت زیر هستند:

table[ 0 ][ 0 ]
table[ 1 ][ 0 ], table[ 1 ][ 1 ]
table[ 2 ][ 0 ], table[ 2 ][ 1 ], table[ 2 ][ 2 ]

با استفاده از چنین ساختاری به سادگی می*توانید ماتریس*ها و سایر داده*ها با فرم چدول دو بعدی را پیاده*سازی کنید. بزرگترین مزیت این حالت به حالت آرایه*ی استاتیک استفاده صحیح از حافظه*ی در دسترس است.

استفاده از تمامی مطالب سایت تنها با ذکر منبع آن به نام سایت علمی نخبگان جوان و ذکر آدرس سایت مجاز است

استفاده از نام و برند نخبگان جوان به هر نحو توسط سایر سایت ها ممنوع بوده و پیگرد قانونی دارد