دوستانی که علاقه به ++cدارن بفرمایین

[uody]

تابع محاسبه فاکتوریل یک عدد بصورت غیر بازگشتی

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


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]

توابع بازگشتی

همان طور که قبلا ذکر شد، امکان فراخوانی یک تابع در تابع دیگر همواره وجود دارد.
خاصیت مهم اینجاست که در زبان ++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]

توابع inline و قالب های تابع

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

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


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

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

[uody]

امروز چند تا برنامه برا این تاپیک میزارم تا .........
// بنویسید که دارای تابعی برای دریافت قاعده و ارتفاع مثلث و تابعی برای محاسیه 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]

آرایه*ی پویای دو بعدی در ++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 ]

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