====== آرگومان‌ها و پارامترها ======
===== ساختار کلی =====
در تعریف تابع **پارامتر** های ورودی (در صورت وجود) به ترتیب به فرمت زیر معرفی میشوند
<code cpp>
ReturnType myFunction (Type_1 name_1,Type_2 name_2,....,Type_n name_n){ statements }
</code>
به عنوان مثال 
<code cpp>
int myFunction (string name,int age,double grade){ statements }
</code>
  * توجه کنید که $Type$ میتواند هریک از انواع موجود در $C++$ باشد و حتی میتواند از نوع $pointer$ باشد .
  * **آرگومان ها** در واقع مقادیر یا عباراتی هستند که موقع فراخوانی تابع به آن داده میشوند.  
  * پارامتر های تابع هنگام فراخوانی تابع همانند **متغیری محلی** تولید شده و با توجه به آرگومان ها و **نوع فراخوانی** مقدار میگیرند .  
<code cpp>
void foo(int x){}  // declaration -- x is a parameter
foo(6);            // 6 is the argument passed to parameter x
foo(y+1);          // the value of y+1 is the argument passed to parameter x
</code>
===== آرایه به عنوان پارامتر =====

میتوانیم برای تابع آرایه نیز به عنوان پارامتر بفرستیم ولی در واقع آرایه فرستاده نمیشود بلکه **اشاره گر** به اولین خانه آن فرستاده میشود (زیرا فرستادن کل آرایه کار بهینه ای نیست ).
<code cpp>
int myFunction(int* param  ){ statements }
int myFunction(int  param[]){ statements }
</code>
دو تعریف بالا مانند یکدیگر عمل میکنند معمولا نیاز است تا اندازه آرایه را نیز به عنوان پارامتری دیگر بفرستیم.
<code cpp>
int myFunction(int param[],int size){ statements }
</code>
اگر آرایه چند بعدی باشد لازم است تا اندازه بعد های **دوم به بعد** را در تعریف مشخص کنیم (مشخص کردن اندازه بعد اول تاثیری ندارد).
<code cpp>
int myFunction(int Info[][100][20]){ statements }
</code>
===== ارسال آرگومان =====
در $C++$ سه روش برای ارسال آرگومان به تابع وجود دارد که هرکدام را به طور مجزا توضیح می دهیم.
==== ارسال آرگومان با مقدار $Value$ $By$ $Argument$ $Passing$ ====
این روش در واقع روش پیشفرض در $C++$ است . در این روش مقدار آرگومان داده شده محاسبه شده و برای تابع فرستاده میشود و در پارامتر مربوطه که همچون متغیری محلی است ذخیره میشود. چون این پارامتر تنها یک کپی از آرگومان است با تغییر آن در تابع مقدار واقعی آرگومان تغییر نمیکند.
<code cpp CallByValue.cpp>
#include<iostream>
using namespace std;

int add(int a,int b){
	a=a+b;
	return a;
}
int main()
{
	cout<<add(1,2)<<endl;
	int a=2,b=2;
	cout<<add(a,b)<<endl;
	cout<<a<<endl;
	return 0;
}
/* OUTPUT :
3
4
2
*/
</code>
==== ارسال آرگومان با ارجاع $Refrence$ $By$ $Argument$ $Passing$ ====
در این حالت پارامتر مورد نظر یک $refrence$ از آرگومان داده شده به تابع میشود و آرگومان مورد نظر باید حتما یک متغیر باشد و دیگر نمیتواند برای مثال مقداری ثابت یا یک عبارت محاسباتی باشد. در تعریف پارامتر باید آن را به شکل یک $refrence$ تعریف کنیم.
<code cpp>
int myFunction(Type& name){ statements }
</code>
برای مثال یک تابع مینویسیم که دو متغیر را $swap$ کند. 
<code cpp Swap.cpp>
#include<iostream>
using namespace std;

void badSwap(int a,int b){
	int c=a;
	a=b;
	b=c;
}
void goodSwap(int& a,int& b){
	int c=a;
	a=b;
	b=c;
}
int main()
{
	int a=1,b=2;
	badSwap(a,b);
	cout<<a<<" "<<b<<endl;
	goodSwap(a,b);
	cout<<a<<" "<<b<<endl;
	return 0;
}
/* OUTPUT :
1 2
2 1
*/
</code>

==== ارسال آرگومان با آدرس $Adress$ $By$ $Argument$ $Passing$ ====
در این حالت پارامتر ورودی از نوع آدرسی یا $pointer$ است و در نتیجه یک آدرس برای تابع فرستاده میشود و در اشاره گر مورد نظر ذخیره میشود. در این حالت چون آدرس را داریم میتوانیم به محتوای موجود در آدرس دسترسی داشته باشیم و در صورت نیاز آن را تغییر دهیم این حالت را میتوان گفت در واقع حالتی خاص از **ارسال آرگومان با مقدار** است.
<code cpp Swap.cpp>
#include<iostream>
using namespace std;

void badSwap(int a,int b){
	int c=a;
	a=b;
	b=c;
}
void goodSwap(int& a,int& b){
	int c=a;
	a=b;
	b=c;
}
void pointerSwap(int* a,int* b){
	int c=(*a);
	(*a)=(*b);
	(*b)=c;
}
int main()
{
	int a=1,b=2;
	badSwap(a,b);
	cout<<a<<" "<<b<<endl;
	goodSwap(a,b);
	cout<<a<<" "<<b<<endl;
	pointerSwap(&a,&b);
	cout<<a<<" "<<b<<endl;
	return 0;
}
/* OUTPUT :
1 2
2 1
1 2
*/
</code>