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

تو زبان C هر متغیر باید یه نوع داده داشته باشه، و این نوع مشخص میکنه که:
چه مقدارهایی میتونه داخلش نگه داره.
چقدر حافظه برای نگهداریش مصرف میشه.
چه عملیاتی میشه روش انجام داد.
انواع دادهها (Data Types) در زبان C به سه گروه اصلی تقسیم میشن:
1 - نوعهای عددی پایه (Primary Numeric Types): (برای نگهداری عددها)
int: عدد صحیح (بدون اعشار)
float: عدد اعشاری با دقت کمتر
double: عدد اعشاری با دقت بیشتر (از f% هم برای نمایش float استفاده میشه هم double)
char: نگهداری یک کاراکتر (مثلا 'A')
مثال:
int a; float b; double c; char d;
تو 99 درصد کامپایلرها، 4 بایت برای نوع داده int در نظر گرفته میشه. پس میتونه عددهایی بین این بازه رو نگه داره:
-2147483648 ta +2147483647
یعنی حدودا 2 میلیارد عدد منفی تا 2 میلیارد عدد مثبت (من تست کردم. اگه بیشتر از این رنج عدد بزنم برنامه خطا میده یا درست اجرا نمیشه) اگه عدد خیلی بزرگی بزنی چی؟ مثلا:
int big = 2147483648;
این عدد از محدودهی مجاز int بیرونه، ممکنه Error بده یا مقدار اشتباه نشون بده.
اگه بخوای عدد بزرگتری نگه داری، باید بری سراغ نوع long int (بعدا توضیح میدم).
چرا char که قراره یه حرف نگه داره تو دستهی نوعهای عددی پایه حساب میشه؟ مگه char با int یکیه؟
اول از همه، char توی C یعنی چی؟ وقتی میگی:
char ch = 'A';
تو واقعا داری یه عدد تو حافظه ذخیره میکنی، نه یه حرف. توی C همهی کاراکترها توی حافظه با کد عددی ASCII شون نگهداری میشن. مثلا:
کاراکتر A با عدد 65 ذخیره میشه.
کاراکتر a با عدد 97
کاراکتر 0 (صفر) با عدد 48
کاراکتر n\ با عدد 10
تاااااا
پس char فقط یه عدد 8 بیتیه (1 بایت) char همون int کوچولوعه! فقط به جای اینکه بهش نگاه عددی داشته باشیم، بهش میگیم، این یه کاراکتره! ولی زیرش واقعا یه عدد ذخیره شده. یه مثال جالب:
char ch = 'A'; printf("%d\n", ch); // خروجی: 65
گفتم ch یه حرف باشه، ولی با d% چاپش کردم! نتیجه عدد 65 عه که معادل کد عددی کاراکتر A داخل جدول ASCII هست.
یه مثال جالب دیگه:
char ch = '8'; printf("%c", ch);
هیچ مشکلی وجود نداره! چرا که من اومدم یه کاراکتر/عدد/نماد ذخیره کردم و چون اون پس زمینه کد عددی هرکدوم رو نگه میداره، خطایی نمیده.
2 - نوعهای تغییر یافته (Modified Types): (نسخههای خاص از نوعهای بالا با ویژگیهای خاص)
Modified یعنی چی؟
تو زبان C یه سری کلمات کلیدی وجود داره که میتونی باهاشون نوع دادههات رو بزرگتر، کوچیکتر یا بدون علامت تعریف کنی. یعنی:
بخوای یه عدد خیلی بزرگ ذخیره کنی باید بری سراغ long
بخوای حافظه کمتری مصرف شه باید بری سراغ short
نخوای عدد منفی ذخیره کنی (عدد بدون علامت) باید بری سراغ unsigned
مثال:
short int age = 21; // یا short age2 = 21; // تو این حالت معمولا 2 بایت از حافظه درگیر میشه و تا بازه 32,767 میشه عدد ذخیره کرد long int big = 2147483647L; // یا long big2 = 2147483647L; // تو این حالت یعنی میخوام عددی نگه دارم که تو int جا نمیشه // برای نمایش این مقادیر باید از ld% استفاده کنم که یعنی long decimal long long int very_big = 214748364711111111LL; // یا long long very_big2 = 214748364711111111LL; // برای عدد فوق العاده بزرگ. اگه بخوام چاپ کنم باید از lld% استفاده کنم. unsigned int un_int = 13; // یا unsigned un_int2 = 13; // برای چاپ این نوع باید از %u استفاده کنم
تو اغلب سیستمهای مدرن، تعریف اندازهها این شکلیه:
نوع short برابر با 2 بایت
نوع int برابر با 4 بایت
نوع long برابر با 4 بایت (تو ویندوز)
نوع long long برابر با 8 بایت
درنتیجه، عبارت long یعنی بلندتر از int ولی نه همیشه بزرگتر بصورت فیزیکی! بلکه تو استاندارد C فقط گفته شده:
long int نباید کوچیکتر از int باشه، ولی ممکنه مساوی باشه.
یه نکته راجب unsigned بگم. وقتی از int معمولی استفاده میکنم بازه عددی که دارم این هست:
−2,147,483,648 ta +2,147,483,647
ولی وقتی از unsigned استفاده میکنم دارم میگم فقط اعداد بدون علامت (اعداد مثبت) رو میخوام باهاشون کار کنم، با اینکار رنج اعداد منفی هم به اعداد مثبت داده میشه. یعنی رنج unsigned برابر هست با:
0 ta 4,294,967,295
با توجه به این مورد به کد زیر دقت کن:
long long int num = 10000000000000000000LL; printf("%lld", num);
این کد کامپایل نمیشه چرا که C نمیتونه این عدد بزرگ رو حتی داخل long long جا بده. یه حرکت میتونم بزنم. میتونم بیام از unsigned استفاده کنم تا رنج اعداد منفی، به اعداد مثبت داده بشه. مثال:
unsigned long long int num = 10000000000000000000ULL; printf("%lld", num);
الان بدون هیچ خطایی کد کامپایل میشه.
ULL آخر عدد یعنی عدد از نوع unsigned long long (عدد خیلی بزرگ مثبت صحیح) عه. چرا لازمه؟ C باید بدوند عدد رو چطور تفسیر کنه (مثلا 10000000000000000000 خیلی بزرگه و ممکنه به اشتباه int در نظر بگیره) اگه این علامت هارو نزارید کامپایلر کد رو کامپایل نمیکنه و خطای بزرگی عدد رو میده.
3 - نوعهای ترکیبی و پیشرفته: (یعنی نوعهایی که از ترکیب چند دادهی دیگه ساخته میشن)
آرایهها (array)
رشتهها (char array)
اشارهگرها (pointer)
struct
union
enum
==> array یا مجموعهای از دادههای همنوع، پشت سر هم در حافظه. یعنی چه؟
فرض کن میخوای 5 تا عدد صحیح رو نگهداری:
int n1 = 10; int n2 = 20; int n3 = 30; int n4 = 40; int n5 = 50;
این روش، هم حافظه رو هدر میده، هم سخت میشه کنترلش کرد. اینجاست که array به دادت میرسه:
int numbers[] = {10, 20, 30, 40, 50};
یعنی یه مجموعه از 5 عدد صحیح که پشت سر هم تو حافظه ذخیره میشن.
(علامت [] هم برای تعریف آرایه و هم برای دسترسی به عناصرش به کار میره)
ساختار یک array:
type_array name_array[تعداد خانه]
مثال:
int scores[10]; // یه آرایه از 10 عدد صحیح char name[20]; // یه آرایه برای ذخیره 20 کاراکتر
مقداردهی آرایه تو دو حالت انجام میشه. حالت اول در لحظه تعریف هست. مثال:
int numbers[] = {1, 2, 3, 4, 5};
حالت دوم جدا جدا. مثال:
int numbers[5]; numbers[0] = 1; numbers[1] = 2; numbers[2] = 3; numbers[3] = 4; numbers[4] = 5;
به کد زیر دقت کن:
int numbers[5] = {1, 2, 3, 4};
چرا با وجود تعریف 5 خانه، 4 مقدار دادم و خطا نگرفت؟
تو C اگه تعداد مقادیر کمتر از اندازه آرایه باشه، باقی خانهها به صورت خودکار صفر مقداردهی میشن. کامپایلر خطایی نمیده چون این یه رفتار استاندارده. مقدار اصلی array:
[0] = 1 [1] = 2 [2] = 3 [3] = 4 [4] = 0 // به صورت خودکار صفر شد
من میتونم کل array رو یکجا با printf نمایش بدم؟ خیر. باید از حلقه استفاده کنم که بعدها باهاش آشنا میشم. پس چرا رشته هارو میتونم نمایش بدم؟ چون اوناهم یک array هستن. رشتهها ([]char) یه مزیت ویژه دارن اونم وجود 0\ (نال ترمیناتور) در انتهاست. تابع printf با فرمت s% اینطوری کار میکنه:
از اولین کاراکتر شروع میکنه به چاپ
تا وقتی به 0\ نرسه ادامه میده
بنابراین میتونه کل کاراکترهای آرایه رو به عنوان رشته پردازش کنه
چرا برای []int نمیشه؟ آرایههای عددی، ترمیناتور خاصی ندارن و printf راهی برای تشخیص پایان آرایه نداره.
آیا مقداردهی آرایهها حتما باید با {} باشه؟ برای آرایههای عددی (غیر رشتهای) بله، باید با {} مقداردهی بشن. البته خود رشته رو هم به شکل زیر میتونم با {} مقدار بدم:
char str1[11] = "Amirhosein"; char str2[11] = {'A', 'm', 'i', 'r', 'h', 'o', 's', 'e', 'i', 'n', '\0'};
چطور به عناصر array دسترسی داشته باشم؟
int numbers[3] = {5, 10, 15}; printf("%d", numbers[0]); // 5
(نمیتونی یه آرایه بسازی که توش چند نوع دادهی مختلف باشه. ولی میتونی از struct برای ساختن مجموعهایی از دادههای متفاوت استفاده کنی، که دقیقا برای همین کار ساخته شده)
==> آشنایی با char array یا رشتهها.
تو زبان C رشته (string) یه نوع دادهی جداگونه مثل پایتون نیست. درواقع، رشته توی C فقط یه چیز سادست: آرایهای از char که آخرش یه کاراکتر مخفی به اسم 0\ (null character) قرار داره. مثال:
char name[] = "Amir";
اینجا یه آرایه ساختم از نوع char که index صفرش برابر هست با 'A'
index اولش برابر هست با 'm'
index دومش برابر هست با 'i'
index سومش برابر هست با 'r'
index چهارمش برابر هست با '0\'
(وقتی از " استفاده کنی اون 0\ خودش اضافه میشه)
قبلا در مورد تفاوت بین ' و " توضیح دادم اما الان سریع یه مرور بکنیم:
char ch = 'A'; // بدون خطا char str[] = "A"; // بدون خطا char ch2 = "A"; // Error: چون یه رشته نمیتونه بره تو یه char
به این کد دقت کن:
char name[4] = {'A', 'm', 'i', 'r'};
کد بالا string نیست! چرا؟ چون باید آخر کار 0\ بزارم. پس درستش میشه:
char name[5] = {'A', 'm', 'i', 'r', '\0'};
بدین شکل هم میشه کار کرد:
#include <stdio.h> int main() { char chars[100]; chars[0] = 'h'; chars[1] = 'e'; chars[2] = 'l'; chars[3] = 'l'; chars[4] = 'o'; printf("%c%c%c%c%c", chars[0], chars[1], chars[2], chars[3], chars[4]); }
خروجی: hello
به کد زیر دقت کن:
#include <stdio.h> int main() { char chars[100]; printf("Enter your name: "); scanf("%s", chars); printf("Hello: %s", chars); }
چرا تو تابع scanf از & استفاده نکردم ولی بازم درست کار کرد؟ چون اسم آرایه (chars) خودش اشارهگر (pointer) به خونهی اول آرایهست! درواقع:
scanf("%s", chars);
معادل اینه:
scanf("%s", &chars[0]);
پس فقط وقتی scanf قراره داخل آرایه مقدار بنویسه (مثل s%) نیازی به & نیست، چون خود اسم آرایه کافیه.
و همچنین، وقتی من گفتم 100 تا خونه برام بزار، ولی مثلا فقط 10 تای اولش استفاده شد، چی میشه؟ بقیه خونهها چیان؟ و 0\ کجا قرار میگیره؟
فرض کن ورودی دادی:
Ali
این 3 تا کاراکتره:
'A'
'l'
'i'
و چون رشتست، C خودش بطور خودکار یه 0\ هم آخرش میذاره، پس در مجموع:
'A' 'l' 'i' '\0'
یعنی فقط 4 خونه از اون char chars[100] استفاده شدن.
بقیه خونهها چی؟ خونههای 4 تا 99 هیچ مقداری ندارن. مقدارشون همونیه که قبل از اجرای برنامه توی حافظه بوده (ممکنه صفر باشه، ممکنه هم آشغال) این خونهها ناشناخته هستن، چون هیچ چیزی توشون ننوشتی. اما چون رشته با 0\ تموم شده، وقتی
printf("%s", chars);
اجرا میشه، فقط تا همون 0\ میره و بقیهی خونهها اصلا کاری بهشون نداره.
به کد زیر دقت کن:
char chars[100]; printf("Enter your name: "); scanf("%s", chars); printf("Hello: %s", chars);
اگه مقدار Amirhosein nazouri رو به عنوان ورودی بدم، فقط Amirhosein دریافت میشه و داخل chars قرار میگیره! اگه بخوام space و مقادیر بعدش هم دریافت کنم، یا باید از یه ترفند داخل scanf استفاده کنم، یا از توابع دیگه استفاده کنم (این پشنهاد میشه) ترفند scanf:
char chars[100]; printf("Enter your name: "); scanf("%[^\n]s", chars); printf("Hello: %s", chars);
با این تکنیک میتونم space و مقادیر بعد از اون رو هم به عنوان ورودی دریافت کنم! اما میتونم از تابع gets هم استفاده کنم. کد:
char chars[100]; printf("Enter your name: "); gets(chars); printf("Hello: %s", chars);
تابع gets برای این ساخته شد که خوندن یک خط کامل (حتی با فاصله) رو راحت کنه. اون کل ورودی کاربر رو تا وقتی که Enter بزنه میخونه و در آرایهایی که بهش دادی ذخیره میکنه. gets دقیقا همون مشکل امنیتی scanf رو داره! gets هیچ راهی برای کنترل اندازه ورودی نداره. تو نمیتونی بهش بگی که بیشتر از 100 کاراکتر نخونه. به همین دلیل، این تابع اونقدر خطرناکه که رسما از استانداردهای جدید زبان C حذف شده و کامپایلرهای مدرن اگه ازش استفاده کنی بهت هشدار جدی میدن (نتیجه: از gets استفاده نکن)
درکنار تابع gets تابع fgets هم داریم. کد:
char chars[100]; printf("Enter your name: "); fgets(chars, 100, stdin); printf("Hello: %s", chars);
حالا اگه کاربر یه رشته 200 کاراکتری هم وارد کنه، fgets فقط 99 کاراکتر اولش رو میخونه، یه 0\ در انتهای اون میزاره و بقیه ورودی رو نادیده میگیره. هیچ Buffer Overflow ایی رخ نمیده.
ساختار کلی fgets:
fgets(char* str, int size, FILE* stream);
char* str: همون آرایه کاراکتری که میخوای رشته در اون ذخیره بشه (مثلا chars).
int size: مهمترین پارامتر. اینجا به fgets میگی که حداکثر چندتا کاراکتر اجازه داره بخونه. این عدد باید برابر با اندازه آرایه باشه. fgets خودش حواسش هست که برای کاراکتر 0\ هم جا بذاره، پس حداکثر size-1 کاراکتر از ورودی میخونه.
FILE* stream: مشخص میکنه که ورودی از کجا خونده بشه. برای خوندن از کیبورد، ما همیشه از stdin یا Standard Input استفاده میکنیم.
(درنهایت، fgets کلا سه ورودی داره)
آرایه های چندبعدی چیه؟ آرایه چند بعدی، یک آرایهایی از آرایهها است.
برای درک بهتر بیا از یک آرایه معمولی (یک بعدی) شروع کنیم. یه آرایه یک بعدی مثل یک قفسه کتاب با چندتا جای خالی پشت سر هم میمونه. هر جای خالی یک شماره داره (ایندکس) و تو میتونی یه کتاب (مقدار) داخلش بذاری.
[ کتاب 0 | کتاب 1 | کتاب 2 | کتاب 3 ]
این دقیقا همون آرایه هایی هست که تا الان کار کردیم.
حالا یه آرایه دو بعدی رو تصور کن. این مثل یه کتابخونه کامل با چندتا قفسه روی هم هست. هر قفسه، خودش یه آرایه یک بعدی از کتابهاست. برای پیدا کردن یه کتاب، تو باید هم شماره قفسه (سطر) رو بدونی و هم جای کتاب در اون قفسه (ستون). مثال:
قفسه 0: [ کتاب 0 | کتاب 1 | کتاب 2 ]
قفسه 1: [ کتاب 0 | کتاب 1 | کتاب 2 ]
قفسه 2: [ کتاب 0 | کتاب 1 | کتاب 2 ]
آرایه سه بعدی هم مثل یک ساختمون چند طبقه از کتابخونهها میمونه! برای پیدا کردن کتاب باید بگی طبقه چندم، قفسه چندم، کتاب چندم.
آرایه های دو بعدی رایجترین و پرکاربردترین نوع آرایه چند بعدی هست. مثال: فرض کن میخوایم نمرات 3 دانشجو رو برای 4 درس مختلف ذخیره کنیم. ما به یک جدول با 3 سطر (برای دانشجوها) و 4 ستون (برای درسها) نیاز داریم. کد:
#include <stdio.h> int main() { // تعریف یک آرایه دو بعدی برای ذخیره نمرات // برای دانشجو ها 3 سطر و برای درس ها 4 ستون int grades[3][4]; // مقداردهی به چندتا از خانهها grades[0][0] = 18; // نمره درس اولِ دانشجوی اول grades[0][1] = 15; // نمره درس دومِ دانشجوی اول grades[1][2] = 20; // نمره درس سومِ دانشجوی دوم printf("Nomre dars aval az daneshjoye aval: %d\n", grades[0][0]); printf("Nomre dars sevom az daneshjoye dovom: %d\n", grades[1][2]); return 0; }
مقدار grades بدین شکله:
[][][][] [][][][] [][][][]
همینطور که قبلا کار کردم، میتونم موقع تعریف آرایه، مقدار هارو براش مشخص کنم. کد:
int matrix[2][3] = { {1, 2, 3}, // مقادیر سطر اول (ایندکس 0) {4, 5, 6} // مقادیر سطر دوم (ایندکس 1) };
برای اینکه به تمام خونههای یه آرایه دو بعدی دسترسی داشته باشی، به دو حلقه for تو در تو نیاز داری. حلقه بیرونی روی سطرها حرکت میکنه و حلقه داخلی روی ستونهای هر سطر. کد:
int matrix[2][3] = { {1, 2, 3}, // مقادیر سطر اول (ایندکس 0) {4, 5, 6} // مقادیر سطر دوم (ایندکس 1) }; for (int i = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { printf("Satr[%d] Sotun[%d]\n", i, j); } }
خروجی:
Satr[0] Sotun[0] Satr[0] Sotun[1] Satr[0] Sotun[2] Satr[1] Sotun[0] Satr[1] Sotun[1] Satr[1] Sotun[2]
آرایه های سه بعدی دقیقا مثل آرایه های دو بعدی هستن، فقط یک بُعد بهش اضافه میشه. درکل ما میتونیم آرایه های چهار بعدی، پنج بعدی و... داشته باشیم اما به ندرت استفاده میشن چون مدیریت کردنشون سخته.
(من یه مقاله نوشتم در مورد توابع مربوط به string در زبان C که پیشنهاد میکنم حتما اون مقاله رو بعد از این توضحات مطالعه کنید)
==> آشنایی با Pointer یا اشارهگرها.
تو زبان C وقتی یه متغیر تعریف میشه و مقداری بهش اختصاص داده میشه، یه خونه تو حافظه RAM سیستم اشغال میکنه و مقدار رو توی اون خونه قرار میده. هر خونه داخل RAM یه آدرس منحصر به فرد داره و این آدرس بصورت هگزادسیمال نمایش داده میشه (مثلا 0x1234).
Pointer یا اشارهگر چیه؟ متغیرهایی که بصورت مستقیم هیچ دادهایی رو داخل خودشون نگه نمیدارن بلکه، آدرس یه متغیر دیگه رو داخل خودشون نگه میدارن رو Pointer مینامیم. به این کد دقت کنید:
int age = 21; int *ptr = &age;
تو خط اول یه متغیر ساختم به اسم age که توش عدد 21 قرار داره. این متغیر یه جایی تو حافظه RAM ذخیره میشه، مثلا تو آدرس 0x1234 (یه عدد فرضی) درنتیجه:
اسمش: age
مقدارش: 21
آدرسش (توی RAM): مثلا 0x1234
تو خط دوم یه متغیر به اسم ptr ساختم. علامت * قبل از اسمش یعنی این متغیر، اشارهگره! یعنی خودش یه عدد صحیح نیست، بلکه آدرس یه عدد صحیح رو قراره نگه داره.
برای مقدار ptr نوشتم age& که یعنی آدرس جایی که متغییر age توی حافظه قرار گرفته رو بدست بیار. فرض کن age توی رم تو آدرس 1000 قرار گرفته. پس age& میشه 1000 (قبلا که راجب scanf صحبت میشد با & آشنا شدیم)
درنتیجه ما اون آدرس (یعنی 1000) رو میریزیم تو ptr.
نکته. برای متغیر اشارهگر هر اسمی میتونیم قرار بدیم اما معمولا ptr قرار میگیره که کوتاه شده pointer هست.
به کد زیر دقت کن:
// یه متغیر معمولی تعریف کردم int number = 13; // یه اشاره گر تعریف کردم که قراره به یک عدد صحیح اشاره کنه int *p_number; // آدرس متغیر "نامبر" رو با عملگر & ذخیره میکنم داخل اشاره گر "پی نامبر" p_number = &number; printf("Meghdar number: %d\n", number); printf("Address Hafeze number: %p\n", &number); printf("=============\n\n"); // مقدار خود اشاره گر فقط یه آدرسه printf("Meghdar p_number (Ke ye addresse): %p\n", p_number); // با عملگر * به محتوای خانهایی که اشاره گر به اون اشاره داره دسترسی پیدا میکنم printf("Meghdari ke pointer be on eshare mikone: %d\n", *p_number); printf("=============\n\n"); // میتونم مقدار متغیر اصلی رو از طریق اشاره گر تغییر بدم *p_number = 21; printf("Meghdar number (bare dovom): %d\n", number); printf("Meghdari ke pointer be on eshare mikone (bare dovom): %d\n", *p_number);
خروجی:
Meghdar number: 13 Address Hafeze number: 0000002fa09ffe64 ============= Meghdar p_number (Ke ye addresse): 0000002fa09ffe64 Meghdari ke pointer be on eshare mikone: 13 ============= Meghdar number (bare dovom): 21 Meghdari ke pointer be on eshare mikone (bare dovom): 21
برای کار با Pointerها، به دو عملگر حیاتی نیاز داریم:
1 - عملگر &: این عملگر وقتی قبل از اسم متغیر میاد، آدرس حافظه اون متغیر رو به ما میده.
2 - عملگر *: این عملگر وقتی قبل از اسم یک پوینتر میاد، به کامپیوتر میگه برو به آدرسی که این پوینتر در خودش ذخیره کرده، و محتوای اون خونه رو به من بده.
به کد زیر دقت کن:
const int i = 0; // i = 5; int *ptr = &i; *ptr = 5; printf("Meghdar ptr: %d\n", *ptr); printf("Meghdar i: %d\n", i);
خروجی:
Meghdar ptr: 5 Meghdar i: 5
تو خط اول یه متغیر به اسم i از نوع int با مقدار 0 تعریف کردم، اما از const استفاده کردم که یعنی مقدار این متغیر نباید تغییر کنه و ثابته. تو خط دوم اومدم مقدار i رو تغییر بدم که خطا میده و کد کامپایل نمیشه (چون i یک const هست) و طبیعیه.
تو خط سوم یه pointer از نوع int با اسم ptr ساختم و آدرس i رو داخلش قرار دادم.
تو خط بعدی اومدم ptr رو صدا زدم (قبلش * گذاشتم یعنی با مقدار توی اون خونه کار دارم) و مقدارش رو به 5 تغییر دادم.
تو خط های آخر اومدم مقدار i و ptr رو نمایش دادم که جفت اونها مقدارشون به 5 تغییر کرده.
سوال! چرا تونستم با استفاده از pointer مقدار رو تغییر بدم؟ مگه از const استفاده نکردم؟
جواب! توی کد گفتم آدرس یه متغیر ثابت (const) رو بده به یه اشارهگر معمولی (غیر-const) و بعد با اشارهگر معمولی مقدار اون رو عوض کن.
یعنی در واقع داری با زور و فریب میگی:
کامپایلر، من قول میدم دست به i نزنم، ولی بعد یهو میری از در پشتی (اشارهگر) مقدارشو تغییر میدی.
راه درست چیه؟
const int i = 0; const int *ptr = &i;
(اگه میخوای اشارهگر بسازی به یه const باید اشارهگرت هم const باشه)
به کد زیر دقت کن:
char c; printf("Enter char: "); scanf("%c", &c);
تابع scanf تو ورودی اول باید براش مشخص بشه که چه نوع دادهایی رو باید از کاربر بگیره، تو ورودی دوم باید آدرس خونهایی رو داخل ram بهش بدم تا مقدار رو بره اونجا قرار بده. من از & استفاده کردم و بعدش c رو نوشتم، یعنی بورو به آدرسی که c به اون اشاره میکنه، تو همون آدرس مقداری که کاربر داده رو قرار بده. حالا بدین شکل هم میتونم کار کنم:
char c; char *p = &c; printf("Enter char: "); scanf("%c", p);
چون pointer بصورت مستقیم به آدرس اشاره داره، دیگه لازم نیست از & استفاده کنم.
به کد زیر دقت کن:
void UpperChar(char *c) { *c = 'A'; } int main() { char a = 'a'; UpperChar(&a); printf("%c", a); }
یه تابع دارم به اسم UpperChar که یک pointer از نوع char ورودی میگیره. یعنی من نباید بهش کاراکتر بدم، بلکه باید آدرس یه کاراکتر رو بهش بدم. بعد توی بدنه، اومدم * گذاشتم که یعنی میخوام به مقدار یا خونهی اون آدرس دسترسی داشته باشم و بعدش مقدارش رو تغییر دادم.
توی تابع main ابتدا یه متغیر به اسم a ساختم از نوع char و کاراکتر a رو به عنوان مقدار بهش دادم.
تو خط بعدش تابع UpperChar رو صدا زدم و برای ورودیش، از & استفاده کردم و a رو بهش دادم (یعنی آدرس اون متغیر فرستاده بشه نه مقدارش)
تو خط آخر مقدار a رو (که داخل تابع main تعریف شده) نمایش دادم که مقدارش A بود که یعنی از a به A تغییر پیدا کرده.
همینطور که میدونید، هر متغیری که داخل تابع تعریف بشه، فقط توی همون تابع قابل استفادست و بیرون اون اعتباری نداره. پس اینجا چطور تونستم بیرون تابع main مقدار a رو تغییر بدم؟ با استفاده از pointer اینکارو انجام دادم. دقت کن من آدرس متغیر رو بهش دادم و آدرس، چیزی هست که ربطی به خود متغیر نداره و هرجا به هر روشی میتونم ازش استفاده کنم.
تو زبان C وقتی یه pointer رو ++ یا -- میکنی، یعنی داری آدرس رو تغییر میدی، نه مقداری که بهش اشاره میکنه. ولی نکته مهم اینه که تغییر آدرس به اندازهی نوع اون pointer انجام میشه. یعنی چی؟ یعنی اگه نوع داده char باشه و من روی pointer اون عمل ++ رو انجام بدم، 1 بایت به آدرس اضافه میشه! ولی اگه نوع داده من int باشه و ++ انجام بدم، 4 بایت اضافه میشه. به این کد دقت کن:
int main() { char c = 'a'; char *ptr = &c; for (int i = 0; i < 100; i++) { printf("%c", *ptr); ptr++; } }
(اینجا دارم بصورت تصادفی حافظه ram رو print میگیرم)
متغیر c مقدار 'a' رو داره و از نوع char هست (یعنی یه بایت توی حافظه).
ptr آدرس c رو نگه میداره، یعنی به اون بایت اشاره میکنه.
توی حلقه، هر بار ptr* چاپ میشه یعنی مقداری که توی اون آدرس هست رو میخونیم.
بعد ++ptr اجرا میشه که یعنی pointer یه بایت جلو میره توی حافظه.
(البته من میتونم بجای ++ptr از ptr = ptr + 10 هم استفاده کنم که اینطوری 10 بایت جلو میره)
ولی مشکل اینجاست:
فقط یه دونه متغیر char به اسم c داریم. یعنی فقط یه بایت حافظه رو خودمون رزرو کردیم.
وقتی توی حلقه، ++ptr میزنیم، داریم میریم سراغ حافظههایی که هیچ تضمینی نیست اصلا مال ما باشن! یعنی ممکنه بره به یه آدرس تصادفی که متعلق به چیزای دیگست (ممکنه توش 0 باشه، یا آشغال، یا حتی باعث کرش بشه). حالا اگه بخوای به شکل درست از این حرکت استفاده کنی چی؟
int main() { char arr[] = "Hello World"; char *ptr = arr; while (*ptr != '\0') { printf("%c", *ptr); ptr++; } }
اینجا چون arr یه رشتست (یعنی یه آرایه از charها)، ما مجازیم که با ++ptr خونهبهخونه توی حافظه حرکت کنیم.
ولی توی مثال قبلی، فقط یه خونه داشتیم و بقیه حرکتها Undefined Behavior بودن (یعنی نتیجهش مشخص نیست، ممکنه درست کار کنه یا اصلا برنامه کرش کنه).
به کد زیر دقت کن:
char h[] = "Salam"; *h = 'H'; printf("%s", h);
خروجی:
Halam
متغیر h فقط آدرس آدرس اولین عنصر آرایه رو نگه میداره! یعنی: h[0]&.
h* یعنی محتوای خونهی حافظهای که h به اون اشاره میکنه! یعنی: h[0].
پس وقتی من اومدم 'h = 'H* رو نوشتم یعنی نمیخوام کل رشته رو تغییر بدم! آرایه ها وقتی تو یک متغیر ذخیره میشن، آدرس خونه اول اون آرایه داخل متغیر ریخته میشه، حالا اون متغیر رو من صدا زدم، قبلش * گذاشتم که یعنی با مقدار اون خونه کار دارم و مقدارش رو تغییر دادم. بدین شکل هم میتونم کار کنم:
char q[] = "Amirhosein"; char *w; w = q; // اینجا آدرس اولین کاراکتر آرایه به اشاره گر تحویل داده میشه w++; *w = 'B'; printf("%s\n\n", q);
تو خط سوم گفتم اشاره گر w به آرایه q اشاره کنه! توی q آدرس اولین خونه آرایه قرار داره که من اومدم اون آدرس رو به w پاس دادم. تو خط بعد نوشتم ++w که یعنی آدرس موجود داخل w باید 1 بایت جلو بره (یعنی بره خونه بعدی) و بعدش اومدم w* رو نوشتم و مقدار جدید رو بهش دادم. حالا این مقدار جدید روی ایندکس 0 آرایه تاثیر نزاشته، بلکه روی index اول آرایه تاثیر گذاشته چون از ++ استفاده کردم.
به کد زیر دقت کن:
char url[] = "https://google.com"; char *url2 = "https://google.com"; printf("%s\n", url); printf("%s", url2);
خروجی:
https://google.com https://google.com
اینا شبیه به هم به نظر میان، ولی زمین تا آسمون فرق دارن از نظر حافظه و رفتار.
توی خط اول داریم یه آرایه از charها تعریف میکنیم و مقدار اولیهش رو هم مشخص کردیم. یعنی:
حافظهای به اندازهی https://google.com (یعنی 18 بایت، شامل 0\) داخل Stack رزرو میشه.
هر حرف داخل این رشته، توی یکی از خونههای این آرایه قرار میگیره.
میتونی مقدار این آرایه رو تغییر بدی (مثال ;'url2[0] = 'H)
این دقیقا معادل این کده:
char url[] = {'h','t','t','p','s',':','/','/','g','o','o','g','l','e','.','c','o','m','\0'};
تو خط دوم یه pointer به char تعریف کردم و اون رو برابر با آدرس اولین حرف رشته https://google.com قرار دادم. اما این رشته به صورت string literal در حافظه ذخیره شده که معمولا توی بخش Read-Only Data Segment قرار داره.
آدرس حافظهی اون رشتهی ثابت میره توی url2.
این حافظه ممکنه قابل نوشتن نباشه. یعنی اگه بزنی
url2[0] = 'H';
برنامه ممکنه کرش کنه یا segmentation fault بده.
رشتهی https://google.com فقط یه بار توی حافظه هست (شبیه constant).
استفاده از این روش باعث مصرف حافظهی کمتر میشه، ولی باید فقط برای خواندن ازش استفاده بشه.
به کد زیر دقت کن:
char url[] = "https://google.com"; printf("%s\n", url); printf("%s\n", &url[3]);
خروجی:
https://google.com ps://google.com
تو خط اول یه آرایه از نوع char به اسم url ساختم. رشته https://google.com رو ریختم داخلش.
تو خط دوم از printf استفاده کردم و s% قرار دادم یعنی میخوام رشته چاپ بشه و بعدش url رو بهش دادم. url در واقع آدرس اولین عنصر آرایست، یعنی url[0]&. تابع printf وقتی با s% صدا زده میشه، از اون آدرس شروع میکنه به خوندن charها تا وقتی به 0\ برسه. پس کل عبارت https://google.com چاپ میشه.
تو خط سوم میام آدرس عنصر سوم آرایه رو به printf میدم. url[3] یعنی چهارمین عنصر آرایه که برابر با p هست. پس وقتی url[3]& رو به printf میدیم، داریم بهش میگیم از اینجا به بعد رشته رو چاپ کن. تابع printf هم از اون آدرس شروع میکنه و تا جایی که به 0\ برسه، ادامه میده.
نکته. وقتی شما یه برنامه C مینویسید، متغیرهای شما عمدتا در دو نوع حافظهی مختلف قرار میگیرن:
1 - حافظه Stack (پُشته): این حافظه برای متغیرهای محلی (local variables) داخل توابع استفاده میشه. اندازش ثابته و در زمان کامپایل مشخص میشه. مثال ;int x یا ;char name[50]
مدیریتش خودکاره. وقتی از یه تابع خارج میشید، تمام متغیرهای محلی اون تابع به طور خودکار از روی Stack پاک میشن. این حافظه سریع ولی محدوده.
بهترین مثال برای درک حافظه Stack یه دسته بشقاب تمیزه که روی هم چیده شدهاند.
قانون اصلی: شما فقط میتونید بشقاب جدید رو روی بالاترین بشقاب بزارید، و فقط میتونید بالاترین بشقاب رو بردارید. به این ساختار میگویند: آخرین ورودی، اولین خروجی است.
Stack در عمل چگونه کار میکند؟ بیا با مثال بشقابها، اجرای یک کد ساده را دنبال کنیم:
int main() { void functionB() { int c = 30; // متغیر تابع B } void functionA() { int b = 20; // متغیر تابع A functionB(); // تابع B را صدا میزند } int main() { int a = 10; // متغیر تابع main functionA(); // تابع A را صدا میزند return 0; } }
main اجرا میشه: یه بشقاب بزرگ برای main روی زمین گذاشته میشه. متغیر a روی این بشقاب قرار میگیره. دسته بشقابها: [ main(a=10) ]
functionA صدا زده میشه: یه بشقاب جدید برای functionA روی بشقاب main قرار میگیره. متغیر b روی این بشقاب جدیده. دسته بشقابها: [ main(a=10) | functionA(b=20) ]
functionB صدا زده میشه: یه بشقاب دیگه برای functionB روی بشقاب functionA قرار میگیره. متغیر c روی بالاترین بشقابه. دسته بشقابها: [ main(a=10) | functionA(b=20) | functionB(c=30) ]
functionB تموم میشه: بالاترین بشقاب (مربوط به functionB) برداشته میشه. متغیر c برای همیشه از بین میره. دسته بشقابها: [ main(a=10) | functionA(b=20) ]
functionA تموم میشه: بشقاب بعدی (مربوط به functionA) برداشته میشه. متغیر b هم نابود میشه. دسته بشقابها: [ main(a=10) ]
main تموم میشه: آخرین بشقاب هم برداشته میشه و حافظه Stack خالی میشه.
اگه اونقدر بشقاب روی هم بزارید که دسته کج بشه و بریزه، به اون Stack Overflow میگن. این خطا زمانی در برنامه شما رخ میده که حافظه محدود Stack تموم بشه.
حالا که با محدودیتهای Stack آشنا شدیم، میفهمیم که چرا به یک حافظه انعطافپذیرتر و بزرگتر به نام Heap نیاز داریم.
2 - حافظه Heap (توده): اگه Stack مثل یه دسته بشقاب منظم بود، Heap را مثل یه انبار بزرگ و درهمریخته تصور کن. تو این انبار، فضاهای خالی با اندازههای مختلف وجود داره. یه انباردار (مثلا malloc) مسئول مدیریت این انباره. وقتی شما به فضا نیاز دارید، پیش انباردار میرید و میگید من یه فضای 10 متری میخوام. انباردار تو انبار میگرده، یه فضای خالی مناسب پیدا میکنه، اون رو به شما اختصاص میده و کلید اون فضا (یعنی آدرس حافظه) رو به شما میده. این کلید همون پوینتر شماست. از این لحظه به بعد، مسئولیت اون فضا با شماست.
ویژگیهای کلیدی حافظه Heap
A - مدیریت دستی (Manual Management): این مهمترین و اصلیترین تفاوت Heap با Stack عه. حافظه Heap به طور خودکار تمیز نمیشه.
تخصیص (Allocation): شما باید صراحتا با توابعی مثل malloc درخواست حافظه کنید.
آزادسازی (Deallocation): شما موظف هستید بعد از اتمام کارتون، با تابع free اون حافظه (کلید) را به انباردار برگردانید.
B - نشت حافظه (Memory Leak): اگه شما فضایی رو از انبار اجاره کنید (حافظه بگیرید) ولی بعدا کلیدش رو گم کنید یا فراموش کنید که به انباردار بگویید کارتون تمام شده (حافظه را free نکنید)، اون فضا برای همیشه (تا پایان اجرای برنامه) اشغالشده باقی میماند، در حالی که هیچکس ازش استفاده نمیکنه. به این پدیده Memory Leak میگن که میتونه به تدریج تمام حافظه سیستم رو مصرف کرده و برنامه رو از کار بیندازه.
C - اندازه بزرگ و انعطافپذیر (Large and Flexible Size): این بزرگترین مزیت Heap است. Heap بخش بسیار بزرگتری از حافظه RAM سیستم رو نسبت به Stack در اختیار داره. شما میتونید دادههای بسیار حجیم (آرایههای بزرگ، ساختارهای داده پیچیده و...) رو روی اون ایجاد کنید. همچنین اندازه حافظه مورد نیازتان رو میتوانید در زمان اجرای برنامه مشخص کنید.
D - سرعت پایینتر (Slower Speed): تخصیص حافظه در Heap کندتر از Stack است. چون انباردار (malloc) باید در انبار بگردد تا یک فضای خالی با اندازه مناسب پیدا کنه. این جستجو زمانبره. در مقابل، Stack فقط یک پوینتر رو بالا و پایین میبره که بسیار سریعه.
E - خطر تکهتکه شدن (Fragmentation): با گذشت زمان و گرفتن و آزاد کردن فضاهای مختلف در حافظه Heap، ممکنه فضاهای خالی کوچیک و پراکندهایی بین فضاهای اشغالشده ایجاد بشه. تو این حالت، با اینکه مجموع فضاهای خالی زیاده، اما ممکنه نتونید یه فضای بزرگ و یکپارچه پیدا کنید. به این مشکل Fragmentation میگن.
چطوری از heap حافظه بگیریم؟
یه تابع وجود داره به اسم malloc که مثل یه انباردار عمل میکنه و کمک میکنه تا از heap حافظه بگیرم. برای استفاده از این تابع باید کتابخونه stdlib.h که ابزارهای مدیریت حافظه داخلش قرار داره رو به برنامه اضافه کنم. کد:
تست
==> آشنایی با struct یا ساختار.
(فعلا این نوع رو بررسی نمیکنم و باید برم جلو تر تا با دیگر مفاهیم آشنا بشم، سپس میام این بخش هم کامل میکنم)
==> آشنایی با union.
(فعلا این نوع رو بررسی نمیکنم و باید برم جلو تر تا با دیگر مفاهیم آشنا بشم، سپس میام این بخش هم کامل میکنم)