تغییر مقادیر متغیرها

مفهوم تغییر مقدار متغیر

در زبان C، پس از ایجاد یک متغیر، می‌توان مقدار آن را در هر نقطه‌ای از برنامه که متغیر در دسترس (در Scope) باشد، تغییر داد. این کار با استفاده از عملگر انتساب (=) انجام می‌شود که مقدار سمت راست را به متغیر سمت چپ نسبت می‌دهد .

مهم‌ترین نکته در تغییر مقادیر متغیرها این است که نوع داده باید با مقدار جدید سازگار باشد. اگر نوع داده با مقدار جدید همخوانی نداشته باشد، کامپایلر ممکن است هشدار دهد یا تبدیل خودکار (Implicit Conversion) انجام دهد که گاهی به از دست رفتن دقت منجر می‌شود .

تغییر مقدار با انتساب مستقیم

ساده‌ترین روش برای تغییر مقدار یک متغیر، استفاده از عملگر انتساب است:

int score = 50;      // ایجاد و مقداردهی اولیه
printf("Score: %d\n", score);  // خروجی: Score: 50

score = 75;          // تغییر مقدار
printf("Score: %d\n", score);  // خروجی: Score: 75

score = 100;         // تغییر دوباره
printf("Score: %d\n", score);  // خروجی: Score: 100

متغیر می‌تواند بارها و بارها در طول اجرای برنامه مقدار جدید بگیرد:

int x = 10;
x = 20;    // مقدار جدید
x = 30;    // مقدار جدیدتر
x = 40;    // و باز هم جدیدتر

تغییر مقدار با استفاده از مقدار فعلی متغیر

در بسیاری از موارد، مقدار جدید متغیر بر اساس مقدار قبلی آن محاسبه می‌شود. مثلاً افزایش یک شمارنده یا تغییر یک مقدار بر اساس عملیات ریاضی:

int counter = 0;
counter = counter + 1;   // افزایش به روش معمول
printf("%d\n", counter); // خروجی: 1

counter = counter + 5;   // افزایش ۵ واحدی
printf("%d\n", counter); // خروجی: 6

counter = counter * 2;   // دو برابر کردن
printf("%d\n", counter); // خروجی: 12

نکته: در عبارت counter = counter + 1;، ابتدا مقدار سمت راست (مقدار فعلی counter به‌علاوهٔ ۱) محاسبه می‌شود، سپس نتیجه به counter نسبت داده می‌شود. این یعنی مقدار قدیمی counter برای محاسبه استفاده می‌شود و سپس جایگزین می‌گردد.

عملگرهای انتساب مختصر (Compound Assignment)

C مجموعه‌ای از عملگرهای انتساب مختصر را فراهم می‌کند که ترکیبی از یک عملگر محاسباتی و عملگر انتساب هستند. این عملگرها کدنویسی را کوتاه‌تر و خواناتر می‌کنند:

int x = 10;
x += 5;    // x = x + 5 → x = 15
x -= 3;    // x = x - 3 → x = 12
x *= 2;    // x = x * 2 → x = 24
x /= 4;    // x = x / 4 → x = 6
x %= 4;    // x = x % 4 → x = 2

printf("x = %d\n", x);  // خروجی: x = 2

عملگرهای افزایش و کاهش (++ و --)

دو عملگر بسیار پرکاربرد برای افزایش یا کاهش یک واحد:

تفاوت بین x++ و ++x در زمان اعمال تغییر است:

int x = 5;
int y;

y = x++;  // y = 5 (مقدار قبلی)، سپس x = 6
printf("x=%d, y=%d\n", x, y);  // خروجی: x=6, y=5

x = 5;
y = ++x;  // ابتدا x = 6، سپس y = 6
printf("x=%d, y=%d\n", x, y);  // خروجی: x=6, y=6

• پس‌افزایش (Post-increment) x++: مقدار فعلی را برمی‌گرداند، سپس افزایش می‌دهد

• پیش‌افزایش (Pre-increment) ++x: ابتدا افزایش می‌دهد، سپس مقدار جدید را برمی‌گرداند

نکته حرفه‌ای: در عبارات پیچیده، استفاده از ++ و -- باید با دقت انجام شود تا از ابهام جلوگیری شود. به‌عنوان مثال، عبارت arr[i++] = i رفتار تعریف‌نشده دارد و در کامپایلرهای مختلف ممکن است نتایج متفاوتی تولید کند .

تغییر مقدار متغیرهای ثابت (Constants) ممنوع است

متغیرهایی که با کلمهٔ کلیدی const تعریف شده‌اند، پس از مقداردهی اولیه قابل تغییر نیستند:

const int MAX_SIZE = 100;
// MAX_SIZE = 200;  // ❌ خطای کامپایل: assignment of read-only variable

تنها راه برای تغییر مقدار یک const، مقداردهی اولیه در زمان تعریف است:

const int MAX_SIZE = 100;    // ✅ درست
// MAX_SIZE = 100;           // ❌ حتی مقداردهی مجدد ممنوع است

تغییر متغیرهای با انواع مختلف و تبدیل نوع (Type Casting)

هنگام تغییر مقدار یک متغیر به یک مقدار از نوع دیگر، کامپایلر ممکن است تبدیل خودکار (Implicit Conversion) انجام دهد:

int x = 10;
float y = 5.7;

x = y;        // x = 5 (بخش اعشاری حذف می‌شود)
printf("x = %d\n", x);  // خروجی: x = 5

y = x;        // y = 5.0 (تبدیل خودکار به float)
printf("y = %.1f\n", y);  // خروجی: y = 5.0

تبدیل نوع صریح (Explicit Type Casting)

برای کنترل دقیق‌تر تبدیل نوع، می‌توان از تبدیل نوع صریح استفاده کرد:

int a = 10, b = 3;
float result;

result = (float)a / b;   // تبدیل a به float برای تقسیم اعشاری
printf("%.2f\n", result); // خروجی: 3.33

result = a / b;          // تقسیم صحیح: a/b = 3
printf("%.2f\n", result); // خروجی: 3.00

نکته: بدون تبدیل نوع، تقسیم دو int یک تقسیم صحیح انجام می‌دهد و بخش اعشاری حذف می‌شود .

تغییر مقادیر در برنامه‌های واقعی

مثال ۱: شمارنده در حلقه

#include <stdio.h>

int main() {
    int counter = 0;
    
    while (counter < 5) {
        printf("Iteration: %d\n", counter);
        counter++;  // افزایش شمارنده
    }
    
    return 0;
}

خروجی:

Iteration: 0
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4

مثال ۲: محاسبهٔ مجموع اعداد

#include <stdio.h>

int main() {
    int sum = 0;
    int i;
    
    for (i = 1; i <= 10; i++) {
        sum += i;  // sum = sum + i
    }
    
    printf("Sum of 1 to 10: %d\n", sum);  // خروجی: 55
    return 0;
}

مثال ۳: مدیریت موجودی انبار

#include <stdio.h>

int main() {
    int stock = 100;
    
    printf("Initial stock: %d\n", stock);
    
    // فروش ۱۵ عدد
    stock -= 15;
    printf("After selling 15: %d\n", stock);
    
    // ورود ۵۰ عدد جدید
    stock += 50;
    printf("After restocking 50: %d\n", stock);
    
    // کاهش ۱۰٪ موجودی
    stock = stock * 0.9;  // تبدیل به int باعث حذف اعشار می‌شود
    printf("After 10%% discount: %d\n", stock);
    
    return 0;
}

خطاهای رایج

۱. استفاده از = به‌جای == در شرط‌ها

int x = 5;
if (x = 10) {  // ❌ این یک انتساب است، نه مقایسه
    printf("x is 10\n");  // همیشه اجرا می‌شود (چون 10 غیرصفر است)
}

راه‌حل: از == برای مقایسه استفاده کنید: if (x == 10)

۲. سرریز (Overflow) در تغییر مقدار

unsigned char small = 255;  // حداکثر مقدار برای unsigned char (0-255)
small = small + 1;          // ❌ سرریز: small = 0 (بازگشت به صفر)

۳. تغییر متغیرهای const

const int MAX = 100;
MAX = 200;  // ❌ خطای کامپایل

۴. تغییر مقدار یک متغیر با نوع ناسازگار بدون توجه به تبدیل

float price = 19.99;
int rounded_price = price;   // هشدار: از دست رفتن دقت (rounded_price = 19)

خلاصه و نکات کلیدی

• برای تغییر مقدار متغیر از عملگر انتساب (=) استفاده می‌شود

• مقدار جدید می‌تواند بر اساس مقدار قبلی متغیر محاسبه شود

• عملگرهای انتساب مختصر (+=, -=, *=, /=, %=) کدنویسی را خواناتر می‌کنند

• عملگرهای ++ و -- برای افزایش و کاهش یک واحد استفاده می‌شوند

• متغیرهای const پس از مقداردهی اولیه قابل تغییر نیستند

• هنگام تغییر مقدار با نوع متفاوت، به تبدیل نوع و از دست رفتن دقت توجه کنید

• از تبدیل نوع صریح ((type)value) برای کنترل دقیق تبدیل‌ها استفاده کنید

• استفاده از = در شرط‌ها به‌جای == یک اشتباه رایج است