by Alireza Aria  

Function | توابع در C++

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

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

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

• تعریف تابع :

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

یک تابع وظیفه ای شبیه به یک ماشین دارد که یک سری ورودی را می گیرد و با انجام عملیات برروی ورودیهای دریافتی، خروجی یا خروجی هایی را تحویل می دهد .

در اولین قدم باید مشخص کنیم که این تابع چه خروجی را به ما می دهد ( در اصطلاح برنامه نویسی بر می گرداند ) و فقط به ذکر نوع خروجی بسنده می کنیم، یعنی اگر عدد صحیح برگرداند از int ، اگر کاراکتر برگرداند از char و به همین ترتیب برای دیگر انواع و اگر هیچ مقداری را برنگرداند از void استفاده می کنیم .

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

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

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

void sample ( int x, int y )  
{
    .
    .
    .
}

• اعلان یا الگوی تابع :

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

#include <iostream.h>
#include <conio.h>

void sample ( int a, int b );  

int main()
{
    .
    .
    .
}

در اعلان (الگو) توابع باید نوع برگشتی، تمامی پارامترها بهمراه نوعشان و نام تابع را بیان نماییم. نام، نوع برگشتی و نوع پارامترها باید کاملا مطابق با موارد متناظر در تعریف تابع باشند، اما لازم نیست که نام پارامترها شبیه به نامهای تعریف تابع باشد .

• فراخوانی تابع :

در نهایت باید در درون برنامه خود، تابع را صدا بزنیم که به اینکار فراخوانی توابع گفته می شود .

int main()
{
    sample (a, b);
}                              

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

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

در کد زیر به بررسی یک مثال ساده از توابع می پردازیم :

#include <iostream.h>
#include <conio.h>

void print(void);      // اعلان تابع

int main()
{
    print();             // فراخوانی تابع
    getch();
    return 0;
}

void print( void )       // تعریف تابع
{
    cout << "This is my first function!" ;
}

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

کد فوق تابعی را با نام print تعریف می کند که بدون خروجی و ورودی است که در بالای برنامه هم به همین ترتیب اعلان شده است و در فراخوانی آن، چون نوعی ندارد ما آنها را خالی می گذاریم .

کامپایلر اجرای برنامه را از تابع main شروع می کند و در خط بعدی به تابع print برمی خورد که فراخوانی شده است لذا در اینجا از تابع main خارج شده و وارد تابع print می شود. انواع ورودی و خروجی و نامشان را چک کرده و در صورت نبود خطا دستورات را انجام داده تا به انتهای تابع می رسد. در اینجا کامپایلر باز به تابع main برمیگردد و ادامه دستورات را اجرا می کند و در نهایت برنامه خاتمه میابد .

مثال) کدی به زبان C++ با استفاده از توابع بنویسید که 2 عدد را در درون تابع main دریافت کند و بعنوان آرگومان به تابعی بفرستد، تابع آنها را با هم جمع کند و نتیجه را به تابع main برگرداند و سپس نتیجه چاپ شود .

#include <iostream.h>
#include <conio.h>

float sum(float, float);      // = float sum(float num1, float num2);

int main()
{
    float num1, num2 ,numSum;

    cout << "Enter first number :" ;
    cin >> num1;
    cout << "Enter second number :" ;
    cin >> num2;

    numSum = sum(num1, num2);             
    cout << numSum;

    getch();
    return 0;
}

float sum(float f1, float f2)       // float sum(float num1, float num2);
{
    float fSum = f1 + f2;
    return fSum;
}

Comment هایی را که در کد بالا می بینید به این معنی است که می شود اینگونه هم نوشت. همانطور که میبینید در تابع main دو عدد را دریافت می کنیم و در فراخوانی تابع آنها را بعنوان آرگومانهای تابع ذکر می کنیم. چون تابع sum مقداری از نوع float را برمی گرداند لازم است که تابع را برابر با همان مقدار برگشتی قرار دهیم تا حاصل جمع اعداد در numSum ذخیره کنیم . اولین comment به این معنی است که می شود در اعلان یک تابع اسم پارامترها را نوشت یا ننوشت اما ذکر انواع ضروری است و دومین comment به این معنی است که نام پارامترها در اعلان و در تعریف توابع هم می تواند یکسان باشد و هم نباشد، نکته مهم نوع و تعداد و ترتیب یکسان آنها می باشد .

در حالت کلی به دو روش می توان پارامترها را به توابع ارسال نمود :

• ارسال از طریق مقدار Arguments passed by value

• ارسال از طریق آدرس Arguments passed by reference

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

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

#include <iostream.h>
#include <conio.h>

int sqr(int x);      // ارسال پارامتر از طریق مقدار

int main()
{
    int num = 10;

    cout << "square = " << sqr(num) << "and number = " << num;

    getch();
    return 0;
}

int sqr(int x)       // ارسال پارامتر از طریق مقدار
{
    x = x * x;
    return x;
}

square = 100 and number = 10

همان طور که در برنامه C++ بالا می بینیم پارانتر x از طریق مقدار به تابع sqr ارسال شده، در درون تابع مقدار پارامتر به توان 2 می رسد و به عدد 100 تغییر میابد اما مقدار num در تابع اصلی همان 10 است و تغییری نمی کند .

دقت بکنید که ما فراخوانی تابع خود را در درون تابع cout انجام داده ایم و در اینحالت نیازی به تعریف یک متغیر برای ذخیره مقدار برگشتی تابع فوق نیست .

توابع inline در برنامه نویسی C++ :

یکی از مسائل مهمی که در برنامه نویسی به هر زبانی قابل توجه است اینه که تا جایی که میشود سرعت اجرای برنامه را بالا برد و زمان اجرای دستورات به حداقل برسد. پیاده سازی برنامه به کمک توابع، مقداری به زمان اجرای برنامه اضافه می کند هرچند که این زمان بسیار کم و در حد میلی ثانیه است اما باری را بر روی برنامه قرار می دهد و علت این تاخیر زمانی این است که در فراخوانی و اعلان توابع، کامپایلر کپی از تابع مو رد نظر را در حافظه قرار می دهد و در فراخوانی تابع به آدرس مذکور مراجعه می کند و در عین حال آدرس موقعیت توقف دستورات در تابع main را نیز ذخیره می کند که پس از پایان تابع به آدرس قبل برگردد و ادامه دستورات را اجرا کند، در نتیجه این آدرس دهی ها و نقل و انتقالات بین آنها بار زمانی را در برنامه ایجاد می کند که در صورت زیاد بودن توابع در برنامه و تعداد فراخوانیهای لازم زمان قابل توجهی خواهد شد .

برای رفع این مورد و بهینه سازی کدنویسی می توان از توابع inline در برنامه نویسی استفاده کرد. در واقع کامپایلر در برخورد با این توابع تعریف تابع را در حافظه کپی نمی کند بلکه با فراخوانی تابع در برنامه، کپی از آنرا در خود برنامه قرار می دهد که مورد آدرس دهی از میان خواهد رفت. بهتر است در جایی که تعریف تابع کم است و از تابع بیش از 2 یا 3 بار در طول برنامه استفاده نمی کنیم از این روش بهره بگیریم و بدانیم که inline از کلمات کلیدی در زبان C++ است. به نحوه تعریف یک تابع inline در برنامه نویسی C++ دقت کنید :

inline type name(parameters) ------>  اعلان و تعریف تابع 
{
    ...
}

برنامه زیر را با هم می بینیم :

#include <iostream.h>
#include <conio.h>

inline int max(int a, int b)      // اعلان و تعریف تابع بصورت یکجا
{
    return a > b ? a : b;
}

int main()
{
    clrscr();

    cout << "maximum of 100 & 101 is : " << max(100, 101);

    getch();
    return 0;
}

maximum of 100 & 101 is : 101                    

در مورد تابع inline این نکته را باید دانست که تعریف تابع، در درون اعلان همان تابع انجام می شود .

تابع دیگری را می بینیم با نام clrscr که این تابع یک توابع از پیش ساخته شده زبان C++ هست و در فایل سرآیند conio قرار دارد و وظیفه آن پاک کردن صفحه نمایش است .

حوزه (ناحیه) تعریف و کار با متغیر ها در برنامه نویسی C++ :

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

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

طول عمر یک متغیر با اتمام حوزه آن از بین رفته و کامپایلر آن کپی را دور می ریزد. منظور از حوزه متغیر همان تابع یا کلاس جاری است .

#include <iostream.h>
#include <conio.h>

void scope(int);

void main()
{
    int x = 10;
    cout << "first value of A=" << x << "\n";
    scope(x);
    cout << "third value of A=" << x;
    
    getch();
}
void scope(int a)
{
    a++;
    cout << "second value of A=" << a << "\n";
}

first value of A=10
second value of A=11
third value of A=10

با اجرای برنامه بالا کامپایلر از سطر 6 برنامه را آغاز می کند. در سطر 8 متغیری از نوع int بنام x را تعریف کردیم پس در حافظه محلی بنام x با مقدار اولیه 10 ذخیره می شود. در سطر 9 و با برخورد کامپایلر با متغیر x کپی از آن ایجاد شده و مقدار آن یعنی 10 چاپ می شود. در سطر 11 کامپایلر به فراخوانی تابع scope می رسد پس ادامه برنامه را در سطر 15 ادامه می دهد. تابع scope دارای پارامتری به نام a است که همان متغیر x در تابع main می باشد چون در فراخوانی تابع scop ما x را به تابع ارسال نمودیم و فقط نامش در اینجا تغییر کرده است. تابع scope در اینجا فقط a را می شناسد و اگر از x استفاده کنیم انرا نمی شناسد پس اعلام خطا می کند مگر اینکه متغیر جدیدی را بنام x در این تابع تعریف کنیم که متغیر جدیدی است و هیچ ربطی به x در تابع main ندارد .

در سطر 17 یک واحد به a اضافه می شود و چون a همان x در main است کامپایلر یک کپی از مقدار آن گرفته و یک واحد به آن اضافه می کند و عدد 11 را چاپ می کند و با پایان تابع و برگشت کامپایلر به تابع main کامپایلر آن کپی را دور می ریزد در حالی که کپی را یک واحد افزایش داده بود و برای متغیر a .

کامپایلر اینبار برنامه را از سطر 11 ادامه می دهد ولی دیگر آن مقداری را که در تابع scope یعنی a را دور ریخته یعنی عمرش تمام شده و فقط در آن تابع معنی داشت. پس باز به سراغ محل x در حافظه که مقدارش همان 10 است رفته و آنرا چاپ کرده و با پایان برنامه و خروج از تابع main (حوزه x ) کپی آنرا هم دور میریزد و عمر آن متغیر هم تمام می شود و حافظه اختصاص داده شده به آنها آزاد می شود .

سربارگذاری توابع در برنامه نویسی C++ (Overloading functions) :

برای درک سربارگذاری توابع کد زیر را می بینیم :

#include <iostream.h>
#include <conio.h>

void func(int a){cout << a << "endl";};
void func(int a, int b){cout << a+b << "endl";};
void func(int a, int b, int c){cout << a+b+c;};

void main()
{
    func(10);
    func(10,10);
    func(10,10,10);
    getch();
}

10
20
30

در بالا می بینیم که سه تابع با نامهای یکسان func را تعریف و صدا زده ایم. درست است که نامها یکسان است اما تعداد آرگومانهای هر تابع با دیگری متفاوت است .

عمل فوق را سربارگذاری توابع گویند یعنی توابعی که دارای نام مشابه هستند ولی در تعداد آرگمانها و ترتیب ورودی آنها با یکدیگر تفاوت دارند. وقتی در تابع main در سطر 11 تابع func صدا زده می شود، کامپایلر با توجه به آرگومانهای آن متوجه می شود که از کدام یک از سربارگذاری تابع استفاده نماید .

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

مقدار دهی اولیه آرگومان های توابع (Initialization functions) :

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

#include <iostream.h>
#include <conio.h>

int initializefunction(int num = 50);
// int initializefunction(int=50);

void main()
{
    cout  << "Initialize value is : " << initializefunction();
    cout  << "Passed value is : " << initializefunction(100);
    getch();
}

int initializefunction(int x)
{
    return x;
}

Initialize value is : 50
Passed value is : 100

خوب همانطور که ملاحظه می کنید تابعی را بنام initializefunction که دارای یک آرگومان از نوع int است ومقداری از نوع int را هم برمی گرداند را در سطر 4 از برنامه بالا اعلان کردیم. به آرگومان تابع دقت نمایید که مقدار اولیه 50 را دریافت می کند. این عمل باعث می شود اگر در فراخوانی تابع مقداری به آن ارسال نشود از همین مقدار 50 بعنوان مقدار پیش فرض استفاده نماید مانند سطر 9 واگر هم مقداری برایش ارسال شد، مقدار پیش فرض را در نظر نگرفته و مقدار ارسالی را لحاظ می کند مانند سطر 10 .

در سطر 5 از برنامه هم روش تعریفی دیگری را مشاهده می کنید که بصورت توضیح آمده است. از هر دو صورت می توان استفاده نمود .