Learn C Programming

lesson ā§Š / ā§Ž ¡ Operator āφāϰ type āĻ•āύāĻ­āĻžāĻ°ā§āĻļāύ

Module ā§Ē ¡ Operator āφāϰ type āĻ•āύāĻ­āĻžāĻ°ā§āĻļāύ

Assignment-āϰ āĻļāĻ°ā§āϟāĻ•āĻžāϟ, ++ āφāϰ --

FreeāĻĒāĻĄāĻŧāĻž

āĻāχ lesson-āĻ āϝāĻž āĻļāĻŋāĻ–āĻŦ⧇

  • total = total + x-āϕ⧇ total += x āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āϜāĻžāύāĻŦ⧇ āĻāϤ⧇ āφāϰ āϕ⧀ āĻŦāĻĻāϞāĻžāϝāĻŧāĨ¤
  • āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ n++-āϰ āĻŽāĻžāύ āĻ•āϤ, āφāϰ ++n-āϰ āϏāĻžāĻĨ⧇ āϤāĻžāϰ āϤāĻĢāĻžāϤ āϕ⧋āĻĨāĻžāϝāĻŧāĨ¤
  • āĻŦā§‹āĻāĻžāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ i = i++ āϕ⧇āύ undefined, āφāϰ āϤāĻžāϰ āĻŦāĻĻāϞ⧇ āύāĻŋāϰāĻžāĻĒāĻĻ āϰ⧂āĻĒāϟāĻž āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

David-āϰ āĻāĻ•āϟāĻž counter āφāϛ⧇ āφāϰ āĻ“ āĻĒāϰ⧇āϰ āĻŽāĻžāύāϟāĻž āϚāĻžāϝāĻŧāĨ¤ āĻ“ āϞ⧇āϖ⧇ i = i++;, āĻ•āĻžāϰāĻŖ āĻĒāĻĄāĻŧāϤ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ "i āĻšāϝāĻŧ⧇ āϝāĻžāĻ• i, āĻāĻ• āĻŦ⧇āĻĄāĻŧ⧇"āĨ¤

Playground āĻāĻ•āϟāĻž āĻ•āĻĨāĻžāĻ“ āύāĻž āĻŦāϞ⧇ āĻ“āϟāĻž compile āĻ•āϰ⧇āĨ¤ āĻ“āϰ āĻŽā§‡āĻļāĻŋāύ⧇ i āĻāĻ•āχ āĻĨāĻžāϕ⧇āĨ¤ āĻ“āϰ āĻāĻ• āĻŦāĻ¨ā§āϧ⧁ āĻāĻ•āχ file āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻ…āĻ¨ā§āϝ āωāĻ¤ā§āϤāϰ āĻĒāĻžāϝāĻŧāĨ¤

āϕ⧋āύ⧋ āĻŽā§‡āĻļāĻŋāύāχ āύāĻˇā§āϟ āύāĻžāĨ¤ āĻ“āχ āϞāĻžāχāύāϟāĻž C-āϕ⧇ āĻāĻ• āϧāĻžāĻĒ⧇ āĻāĻ•āχ āĻŦāĻžāĻ•ā§āϏ⧇ āĻĻ⧁āχāϟāĻž āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻŦāϞ⧇, āφāϰ standard āĻŦāϞāϤ⧇āχ āϰāĻžāϜāĻŋ āύāĻž āϕ⧋āύāϟāĻž āφāϗ⧇ āϜāĻŋāϤāĻŦ⧇āĨ¤

āĻšāĻžāϤ⧇ āĻĨāĻžāĻ•āĻž variable āĻŦāĻĻāϞāĻžāύ⧋āϰ āĻĒāĻžāρāϚāϟāĻž āĻļāĻ°ā§āϟāĻ•āĻžāϟ

āĻāĻ•āϟāĻž āϚāϞāĻŽāĻžāύ āϝ⧋āĻ—āĻĢāϞ⧇ āϝ⧋āĻ— āĻ•āϰāĻž āĻāϤ āĻŦ⧇āĻļāĻŋ āĻĻāϰāĻ•āĻžāϰ āĻšāϝāĻŧ āϝ⧇ C āϤāĻžāϰ āϜāĻ¨ā§āϝ āϛ⧋āϟ āĻāĻ•āϟāĻž āĻŦāĻžāύāĻžāύ āϰ⧇āϖ⧇āϛ⧇āĨ¤

Compound assignment operator-āϗ⧁āϞ⧋

total += x      āĻŽāĻžāύ⧇   total = total + x
total -= x      āĻŽāĻžāύ⧇   total = total - x
total *= x      āĻŽāĻžāύ⧇   total = total * x
total /= x      āĻŽāĻžāύ⧇   total = total / x
total %= x      āĻŽāĻžāύ⧇   total = total % x
  • Variable-āϟāĻžāϰ āύāĻžāĻŽ āĻāĻ•āĻŦāĻžāϰ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ, āĻĻ⧁āχāĻŦāĻžāϰ āύāĻžāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āύāĻžāĻŽā§‡ āϟāĻžāχāĻĒā§‹ āĻšāĻ“āϝāĻŧāĻžāϰ bug āĻāχ āϰ⧂āĻĒ⧇ āĻšāϤ⧇āχ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤
  • Operator āĻŦāϏ⧇ =-āϰ āφāϗ⧇, āĻ•āĻ–āύ⧋ āĻĒāϰ⧇ āύāĻžāĨ¤ =+ āφāϞāĻžāĻĻāĻž āĻāĻ•āϟāĻž āϜāĻŋāύāĻŋāϏ, āϝ⧇āϟāĻž āĻŦ⧈āϧ āφāϰ āĻ…āϕ⧇āĻœā§‹āĨ¤
  • āĻĄāĻžāύ āĻĒāĻžāĻļāϟāĻž āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻšāĻŋāϏāĻžāĻŦ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āφāϗ⧇, āϤāĻžāϰāĻĒāϰ operator-āϟāĻž āϞāĻžāϗ⧇āĨ¤
#include <stdio.h>

int main(void)
{
    int total = 100;

    total += 25;
    printf("after +=  %d\n", total);
    total -= 5;
    printf("after -=  %d\n", total);
    total *= 2;
    printf("after *=  %d\n", total);
    total /= 7;
    printf("after /=  %d\n", total);
    total %= 10;
    printf("after %%=  %d\n", total);
    return 0;
}
after +=  125
after -=  120
after *=  240
after /=  34
after %=  4

āϚāϤ⧁āĻ°ā§āĻĨ āϞāĻžāχāύāϟāĻž āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰāĻžāϰ āĻŽāϤ⧋āĨ¤ 240-āϕ⧇ 7 āĻĻāĻŋāϝāĻŧ⧇ āĻ­āĻžāĻ— āĻ•āϰāϞ⧇ 34.28, āφāϰ total āĻāĻ•āϟāĻž int, āϤāĻžāχ āωāĻ¤ā§āϤāϰ 34āĨ¤

āϤāĻžāχ /= lesson 1-āϰ integer division āϏāĻ™ā§āϗ⧇ āύāĻŋāϝāĻŧ⧇āχ āφāϏ⧇āĨ¤ āĻļāĻ°ā§āϟāĻ•āĻžāϟ āĻŦāĻžāύāĻžāύāϟāĻž āĻŦāĻĻāϞ⧇āϛ⧇, āĻ…āĻ™ā§āĻ•āϟāĻž āύāĻžāĨ¤

āĻļāĻ°ā§āϟāĻ•āĻžāĻŸā§‡āϰ āĻ­āĻŋāϤāϰ⧇ āϞ⧁āĻ•āĻŋāϝāĻŧ⧇ āĻĨāĻžāĻ•āĻž āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ

total *= 1.5 āĻ āĻŋāĻ• total = total * 1.5 āύāĻžāĨ¤ āĻ“āϟāĻž total = (int)(total * 1.5), cast-āϟāĻž āϤ⧋āĻŽāĻžāϰ āĻšāϝāĻŧ⧇ āϞ⧇āĻ–āĻžāĨ¤

āĻļ⧇āώ āϧāĻžāĻĒāϟāĻž āύ⧀āϰāĻŦāĨ¤ āĻāχ āϜāĻ¨ā§āϝāχ āĻĻ⧁āχāϟāĻž āϰ⧂āĻĒ āĻšā§āĻŦāĻšā§ āĻāĻ• āύāĻž, āφāϰ āĻāχ āϜāĻ¨ā§āϝāχ āĻāĻ•āϟāĻž āĻĻāĻžāĻŽ āϚ⧁āĻĒāϚāĻžāĻĒ āϤāĻžāϰ āĻ­āĻ—ā§āύāĻžāĻ‚āĻļ āĻšāĻžāϰāĻžāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    int price = 7;

    price *= 1.5;

    printf("%d\n", price);
    return 0;
}
10

āϏāĻžāϤ āϗ⧁āĻŖ 1.5 āĻšāϞ⧋ 10.5āĨ¤ āϗ⧁āĻŖāϟāĻž āϏāĻ¤ā§āϝāĻŋāχ double-āĻ āĻšāϝāĻŧ⧇āĻ›āĻŋāϞ, āϤāĻžāϰāĻĒāϰ 10.5-āϕ⧇ āϕ⧇āĻŸā§‡ āĻāĻ•āϟāĻž int-āĻ āφāρāϟāĻžāύ⧋ āĻšāϝāĻŧ⧇āϛ⧇āĨ¤

āϕ⧋āύ⧋ command line-āĻāχ āĻāϟāĻž āύāĻŋāϝāĻŧ⧇ āĻ•āĻŋāϛ⧁ āĻŦāϞāĻž āĻšāϝāĻŧ āύāĻž, āĻāĻŽāύāĻ•āĻŋ -Wall -Wextra-āϤ⧇āĻ“ āύāĻžāĨ¤ āĻ¸ā§āĻĨāĻžāύ⧀āϝāĻŧ āĻāĻ•āϟāĻž gcc -Wconversion āĻŦāϞ⧇ warning: conversion from 'double' to 'int' may change valueāĨ¤

āϤāĻžāχ compound assignment āϏāĻŦ āϏāĻŽāϝāĻŧ āĻŦāĻžāρ āĻĒāĻžāĻļ⧇āϰ variable-āϰ type-āĻ āĻĢāĻŋāϰ⧇ āφāϏ⧇āĨ¤ Lesson 6 āĻ“āχ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰāϟāĻžāϰ āφāϏāϞ āύāĻžāĻŽ āĻĻ⧇āĻŦ⧇āĨ¤

++ āφāϰ --, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϰ⧂āĻĒ āϝ⧇ āĻŽāĻžāύ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ

n++ āφāϰ ++n āĻĻ⧁āχāϟāĻžāχ n-āĻ 1 āϝ⧋āĻ— āĻ•āϰ⧇āĨ¤ āϤāĻĢāĻžāϤ āĻšāϞ⧋ āĻ•āĻžāϜāϟāĻž āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ expression-āϟāĻžāϰ āĻŽāĻžāύ āĻ•āϤāĨ¤

n++ āĻšāϞ⧋ postfix āϰ⧂āĻĒāĨ¤ āĻ“āϟāĻžāϰ āĻŽāĻžāύ āĻĒ⧁āϰāύ⧋ nāĨ¤ ++n āĻšāϞ⧋ prefix āϰ⧂āĻĒ, āφāϰ āĻ“āϟāĻžāϰ āĻŽāĻžāύ āύāϤ⧁āύāϟāĻžāĨ¤

n++ āφāϰ ++n āĻŦāĻžāĻ•ā§āϏāϟāĻžāϕ⧇ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āĻŦāĻĻāϞāĻžāϝāĻŧ āφāϰ āφāϞāĻžāĻĻāĻž āĻŽāĻžāύ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ āĻŦāĻžāĻ•ā§āϏ⧇ āĻāĻ•āχ āĻĢāϞ, expression-āĻ āφāϞāĻžāĻĻāĻž āĻŽāĻžāύ n++ n 5 āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ 5 n 6 āĻĒ⧁āϰāύ⧋ āĻŽāĻžāύāϟāĻž āφāϗ⧇ āĻŦāĻžāĻ•ā§āϏ āϛ⧇āĻĄāĻŧ⧇āϛ⧇ ++m m 5 āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ 6 m 6 āĻŦāĻžāĻ•ā§āϏāϟāĻž āφāϗ⧇ āĻŦ⧇āĻĄāĻŧ⧇āϛ⧇ āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž āϞāĻžāχāύ⧇ n++ āφāϰ ++n āĻšā§āĻŦāĻšā§ āĻāĻ•āχ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤
#include <stdio.h>

int main(void)
{
    int n = 5;
    printf("n++ gives %d\n", n++);
    printf("n is now  %d\n", n);

    int m = 5;
    printf("++m gives %d\n", ++m);
    printf("m is now  %d\n", m);
    return 0;
}
n++ gives 5
n is now  6
++m gives 6
m is now  6

āĻĻ⧁āχāϟāĻž variable-āχ āĻļ⧇āώ⧇ 6-āϤ⧇ āĻĻāĻžāρāĻĄāĻŧāĻžāϝāĻŧāĨ¤ āϤāĻĢāĻžāϤ āĻļ⧁āϧ⧁ printf-āϰ āĻ•āĻžāϛ⧇ āϕ⧋āύ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻĒ⧌āρāĻ›āĻžāϞāĨ¤

āϤāĻžāχ āϕ⧋āύ āϰ⧂āĻĒāϟāĻž āύ⧇āĻŦ⧇ āϏ⧇āϟāĻž āĻ āĻŋāĻ• āϤāĻ–āύāχ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āϝāĻ–āύ āϤ⧁āĻŽāĻŋ āĻŽāĻžāύāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻ›āĨ¤ āύāĻŋāĻœā§‡āϰ statement-āĻ āĻĻ⧁āχāϟāĻž āϰ⧂āĻĒ āĻāĻ•āĨ¤

āĻāĻ• expression-āĻ āĻāĻ• āĻŦāĻžāĻ•ā§āϏ⧇ āĻĻ⧁āχāϟāĻž āĻŦāĻĻāϞ, āĻŽāĻžāύ⧇ undefined

āĻĻ⧁āχāϟāĻž statement-āϰ āĻŽāĻžāĻā§‡ C āĻ•āĻĨāĻž āĻĻ⧇āϝāĻŧ āϏāĻŦ āĻ•āĻžāϜ āĻļ⧇āώāĨ¤ āĻāĻ• expression-āϰ āĻ­āĻŋāϤāϰ⧇ āĻ“ āĻ…āύ⧇āĻ• āĻ•āĻŽ āĻ•āĻĨāĻž āĻĻ⧇āϝāĻŧāĨ¤

āĻāχ track-āϰ āύāĻŋāϝāĻŧāĻŽāϟāĻž āϏ⧋āϜāĻž āĻ•āĻĨāĻžāϝāĻŧ: āĻāĻ•āϟāĻž expression āϝāĻĻāĻŋ āĻāĻ•āϟāĻž variable āĻŦāĻĻāϞāĻžāϝāĻŧ āφāϰ āϏ⧇āϟāĻžāϕ⧇āχ āφāĻŦāĻžāϰ āĻĒāĻĄāĻŧ⧇ āĻŦāĻž āĻŦāĻĻāϞāĻžāϝāĻŧ, āϤāĻžāĻšāϞ⧇ āφāϚāϰāĻŖāϟāĻž undefinedāĨ¤ unspecified āύāĻž, compiler-āϭ⧇āĻĻ⧇ āφāϞāĻžāĻĻāĻž āύāĻž: undefinedāĨ¤

i = i++ āĻ āĻŋāĻ• āϏ⧇āϟāĻžāχ āĻ•āϰ⧇āĨ¤ āĻ“āϟāĻž i-āϤ⧇ assign āĻ•āϰ⧇ āφāϰ i-āϕ⧇ āĻŦāĻžāĻĄāĻŧāĻžāϝāĻŧ, āφāϰ āĻ“āχ āĻĻ⧁āχ āϘāϟāύāĻžāϰ āϕ⧋āύ⧋ āĻ•ā§āϰāĻŽ āύ⧇āχāĨ¤

Undefined āĻŽāĻžāύ⧇ standard program-āϰ āωāĻĒāϰ āϕ⧋āύ⧋ āĻļāĻ°ā§āϤāχ āĻĻ⧇āϝāĻŧ āύāĻžāĨ¤ āĻāχ track-āϰ āϕ⧋āĻĨāĻžāĻ“ āĻāĻŽāύ āϞāĻžāχāύ⧇āϰ āϕ⧋āύ⧋ output āϞ⧇āĻ–āĻž āύ⧇āχ, āĻ•āĻžāϰāĻŖ āϞ⧇āĻ–āĻžāϰ āĻŽāϤ⧋ āϏāĻ āĻŋāĻ• āϕ⧋āύ⧋ output āύ⧇āχāĨ¤

int i = 3;
i = i++;

Playground āĻāχ āύāĻŋāϝāĻŧ⧇ āĻ•āĻŋāϛ⧁ āĻŦāϞ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž -Wall-āϰ āĻĒāĻŋāĻ›āύ⧇āĨ¤ āĻ¸ā§āĻĨāĻžāύ⧀āϝāĻŧ gcc -Wall āĻŦāϞ⧇ warning: operation on 'i' may be undefined, āφāϰ "may" āĻļāĻŦā§āĻĻāϟāĻž compiler-āϰ āϏāϤāϤāĻž, āĻ•āĻžāϰāĻŖ āĻāϟāĻž āϧāϰāĻž āϏāĻ¤ā§āϝāĻŋāχ āĻ•āĻ āĻŋāύāĨ¤

āĻāχ track āϝ⧇ āύāĻŋāϝāĻŧāĻŽāϟāĻž āĻŽāĻžāύ⧇

āύāĻŋāϝāĻŧāĻŽāϟāĻž āϛ⧋āϟ: ++ āφāϰ -- āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž āϞāĻžāχāύ⧇ āϞ⧇āĻ–ā§‹, āĻ•āĻ–āύ⧋ āĻŦāĻĄāĻŧ āϕ⧋āύ⧋ expression-āϰ āĻ­āĻŋāϤāϰ⧇ āύāĻžāĨ¤

āĻāϤ⧇ āϤ⧁āĻŽāĻŋ āĻ•āĻŋāϛ⧁āχ āĻšāĻžāϰāĻžāĻ“ āύāĻžāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āĻāĻ•āϟāĻž āĻĻ⧁āχ-āϞāĻžāχāύ⧇āϰ āϰ⧂āĻĒ āφāϛ⧇, āϝ⧇āϟāĻž āĻāĻ•āχ āĻ•āĻĨāĻž āĻŦāϞ⧇ āφāϰ āϏāĻŦ āϏāĻŽāϝāĻŧ definedāĨ¤

#include <stdio.h>

int main(void)
{
    int i = 3;
    int copy = i;
    i++;

    printf("copy %d, i %d\n", copy, i);
    return 0;
}
copy 3, i 4

āĻĻ⧁āχāϟāĻž statement, āĻĻ⧁āχāϟāĻž āύāĻŋāĻļā§āϚāĻŋāϤ āϧāĻžāĻĒ, āφāϰ āĻāĻ•āϟāĻžāχ āĻĒāĻĄāĻŧāĻžāϰ āϧāϰāύāĨ¤ Module 6 i++-āϕ⧇ āĻ­āĻžāώāĻžāϰ āϰāĻžāĻ–āĻž āϏ⧇āχ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻŦāϏāĻžāĻŦ⧇, āĻāĻ•āϟāĻž for header-āϰ āϤ⧃āϤ⧀āϝāĻŧ āϘāϰ⧇āĨ¤

āϤāĻžāχ āĻļāĻ°ā§āϟāĻ•āĻžāϟāϟāĻž āĻ¸ā§āĻŦāĻžāĻ—āϤ; āĻ“āϟāĻžāϕ⧇ āĻ…āĻ¨ā§āϝ āĻāĻ•āϟāĻž expression-āϰ āĻ­āĻŋāϤāϰ⧇ āϞ⧁āĻ•āĻžāύ⧋ āύāĻžāĨ¤

Example 1: āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ āϚāϞāĻŽāĻžāύ āϝ⧋āĻ—āĻĢāϞ

āĻāĻ•āϟāĻž āĻŦāĻžāĻ•ā§āϏ, āϤāĻŋāύāϟāĻž āϝ⧋āĻ—, āĻļ⧇āώ⧇ āĻāĻ•āĻŦāĻžāϰ āĻ›āĻžāĻĒāĻžāĨ¤

#include <stdio.h>

int main(void)
{
    int total = 0;

    total += 10;
    total += 20;
    total += 30;

    printf("%d\n", total);
    return 0;
}
60

Module 6 āϤāĻŋāύ āϞāĻžāχāύ⧇āϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻāĻ•āϟāĻž loop āĻŦāϏāĻžāĻŦ⧇āĨ¤ āϤāĻ–āύ⧋ operator-āϟāĻž āĻŦāĻĻāϞāĻžāĻŦ⧇ āύāĻžāĨ¤

Run in Compiler
Example 2: āϝ⧇ counter āĻĒ⧁āϰāύ⧋ āĻŽāĻžāύāϟāĻž āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ

āĻāĻ•āϟāĻž āϟāĻŋāĻ•āĻŋāĻŸā§‡āϰ āϞāĻžāχāύāĨ¤ āϤ⧋āĻŽāĻžāϕ⧇ āϝ⧇ āύāĻŽā§āĻŦāϰāϟāĻž āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ, counter āϏāϰāĻžāϰ āφāϗ⧇ āϏ⧇āϟāĻžāχ āĻ›āĻŋāϞāĨ¤

#include <stdio.h>

int main(void)
{
    int next_ticket = 41;

    int mine = next_ticket++;
    int yours = next_ticket++;

    printf("mine  %d\n", mine);
    printf("yours %d\n", yours);
    printf("next  %d\n", next_ticket);
    return 0;
}
mine  41
yours 42
next  43

āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ next_ticket-āϕ⧇ āĻāĻ•āĻŦāĻžāϰ āϛ⧋āρāϝāĻŧ, āϤāĻžāχ āĻāĻ–āĻžāύ⧇ āĻ•āĻŋāϛ⧁āχ undefined āύāĻžāĨ¤ Postfix-āχ āĻ āĻŋāĻ• āϰ⧂āĻĒ: āϤ⧁āĻŽāĻŋ āύ⧇āĻ“āϝāĻŧāĻžāϰ āφāϗ⧇ āϝ⧇ āϟāĻŋāĻ•āĻŋāϟāϟāĻž āĻ–āĻžāϞāĻŋ āĻ›āĻŋāϞ, āϏ⧇āϟāĻžāχ āϤ⧁āĻŽāĻŋ āϚāĻžāĻ“āĨ¤

Run in Compiler
Example 3: āĻļāĻŋāĻ•ā§āώāĻžāύāĻŦāĻŋāĻļ āφāϏāϞ⧇ āϝ⧇ āϝ⧋āĻ—āĻĢāϞāϟāĻž āϞ⧇āϖ⧇

āϚāĻžāϰāϟāĻž āĻŽāĻžāĻ°ā§āĻ• āĻĸā§‹āϕ⧇, āĻāĻ•āϟāĻž āϝ⧋āĻ—āĻĢāϞ āφāϰ āĻāĻ•āϟāĻž āĻ—āĻŖāύāĻž āĻŦ⧇āϰ⧋āϝāĻŧ, āϏāĻŦāχ compound assignment āĻĻāĻŋāϝāĻŧ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    scanf("%d %d %d %d", &a, &b, &c, &d);

    int total = 0;
    int count = 0;

    total += a;
    count++;
    total += b;
    count++;
    total += c;
    count++;
    total += d;
    count++;

    printf("total %d over %d marks\n", total, count);
    printf("average %.2f\n", total / (double)count);
    return 0;
}
total 329 over 4 marks
average 82.25

āĻ“āχ output-āϟāĻž 75 82 82 90 input-āϰ āϜāĻ¨ā§āϝāĨ¤ (double)-āϟāĻž lesson 6-āϰ cast, āϝ⧇āϟāĻž āĻļ⧇āώ āϞāĻžāχāύ⧇ lesson 1-āϰ āĻ•āĻžāϜāϟāĻžāχ āĻ•āϰāϛ⧇āĨ¤

Run in Compiler

āĻāϟāĻž āϕ⧋āĻĨāĻžāϝāĻŧ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇

  • āϤ⧁āĻŽāĻŋ āϝāϤ loop āϞāĻŋāĻ–āĻŦ⧇āĨ¤ āĻāĻ•āϟāĻž for header-āϰ āϤ⧃āϤ⧀āϝāĻŧ āϘāϰ⧇ āĻĒā§āϰāĻžāϝāĻŧ āϏāĻŦ āϏāĻŽāϝāĻŧ i++ āĻĨāĻžāϕ⧇āĨ¤ Module 6 āĻĻ⧁āχ lesson āĻĒāϰ⧇āχ āφāϏāϛ⧇ āφāϰ āĻ“āϟāĻž āĻāχ operator-āϰ āωāĻĒāϰāχ āϚāϞ⧇āĨ¤
  • Reference countingāĨ¤ CPython āĻĒā§āϰāϤāĻŋāϟāĻž object-āĻ āĻāĻ•āϟāĻž āĻ—ā§‹āύāĻž āϰāĻžāϖ⧇ āφāϰ āύāĻžāĻŽ āφāϏāĻž-āϝāĻžāĻ“āϝāĻŧāĻžāϰ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇ āϤāĻžāϤ⧇ ++ āφāϰ -- āϚāĻžāϞāĻžāϝāĻŧāĨ¤ āĻ—ā§‹āύāĻžāϟāĻž āĻļā§‚āĻ¨ā§āϝ⧇ āύāĻžāĻŽāϞ⧇ āϜāĻžāϝāĻŧāĻ—āĻžāϟāĻž āϛ⧇āĻĄāĻŧ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤
  • Server-āϰ byte counterāĨ¤ Nginx āĻĒā§āϰāϤāĻŋāϟāĻž āϞ⧇āĻ–āĻž āϟ⧁āĻ•āϰāĻžāϕ⧇ āĻāĻ•āϟāĻž āϚāϞāĻŽāĻžāύ āϝ⧋āĻ—āĻĢāϞ⧇ += āĻĻāĻŋāϝāĻŧ⧇ āϝ⧋āĻ— āĻ•āϰ⧇āĨ¤ āϤ⧋āĻŽāĻžāϰ bandwidth-āϰ āĻŦāĻŋāϞ āĻ“āχ āϝ⧋āĻ—āĻĢāϞ āĻĨ⧇āϕ⧇āχ āĻšāĻŋāϏāĻžāĻŦ āĻšāϝāĻŧāĨ¤
  • āϖ⧇āϞāĻžāϰ āĻ¸ā§āϕ⧋āϰ āφāϰ healthāĨ¤ score += 10 āφāϰ health -= damage āϝ⧇āϕ⧋āύ⧋ game loop-āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻšā§‡āύāĻž āĻĻ⧁āχ āϞāĻžāχāύ, āφāϰ āĻ“āϰāĻž āĻāχ lesson-āϰ āĻĒā§āϰāĻĨāĻŽ āĻ…āĻ‚āĻļāĨ¤

āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇

ā§§. āĻāĻ• expression-āĻ āĻāĻ•āϟāĻž variable āĻĻ⧁āχāĻŦāĻžāϰ āĻŦāĻĻāϞāĻžāύ⧋āĨ¤

int i = 3;
i = i++;

Playground-āĻ āύ⧀āϰāĻŦ; āĻ¸ā§āĻĨāĻžāύ⧀āϝāĻŧ gcc -Wall āĻŦāϞ⧇ warning: operation on 'i' may be undefinedāĨ¤ āĻāϟāĻž undefined behaviour, āϤāĻžāχ āĻāĻ–āĻžāύ⧇ āϕ⧋āύ⧋ output āϞ⧇āĻ–āĻž āύ⧇āχāĨ¤ i++; āύāĻŋāĻœā§‡āϰ āϞāĻžāχāύ⧇ āϞ⧇āĻ–ā§‹āĨ¤

⧍. āϏāĻŽāĻžāύ-āϚāĻŋāĻšā§āύ⧇āϰ āĻĒāϰ⧇ operator āϞ⧇āĻ–āĻžāĨ¤

int total = 100;
total =+ 25;
printf("%d\n", total);

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχ, āφāϰ āĻ›āĻžāĻĒ⧇ 25āĨ¤ =+ āĻŽāĻžāύ⧇ āϧāύāĻžāĻ¤ā§āĻŽāĻ• 25 assign āĻ•āϰāĻž, āϝ⧇āϟāĻž āĻŦ⧈āϧ āφāϰ āϤ⧋āĻŽāĻžāϰ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āύāĻžāĨ¤ Operator āĻŦāϏ⧇ =-āϰ āφāϗ⧇āĨ¤

ā§Š. /= āĻ­āĻ—ā§āύāĻžāĻ‚āĻļ āϰāĻžāĻ–āĻŦ⧇ āĻŦāϞ⧇ āφāĻļāĻž āĻ•āϰāĻžāĨ¤

int total = 7;
total /= 2;
printf("%d\n", total);

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχ, āφāϰ āĻ›āĻžāĻĒ⧇ 3āĨ¤ āĻĻ⧁āχ āĻĒāĻžāĻļāχ āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, āϤāĻžāχ lesson 1-āϰ integer division āϚāϞ⧇āĨ¤ āĻ­āĻ—ā§āύāĻžāĻ‚āĻļ āĻĻāϰāĻ•āĻžāϰ āĻšāϞ⧇ āĻāĻ•āϟāĻž double variable āύāĻžāĻ“āĨ¤

ā§Ē. Postfix-āϰ āĻŽāĻžāύāϕ⧇ āύāϤ⧁āύ āĻŽāĻžāύ āĻ­āĻžāĻŦāĻžāĨ¤

int n = 5;
printf("%d\n", n++);

āϕ⧋āύ⧋ command line-āĻāχ āĻŦāĻžāĻ°ā§āϤāĻž āύ⧇āχ, āφāϰ āĻ›āĻžāĻĒ⧇ 5, 6 āύāĻžāĨ¤ āĻŦāĻžāĻĄāĻŧāĻžāϟāĻž āϘāĻŸā§‡āϛ⧇ āĻ āĻŋāĻ•āχ; printf-āϰ āĻ•āĻžāϛ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āĻŽāĻžāύāϟāĻž āϤāĻžāϰ āφāϗ⧇āχ āύ⧇āĻ“āϝāĻŧāĻžāĨ¤ āύāϤ⧁āύ āĻŽāĻžāύ āϚāĻžāχāϞ⧇ ++n āϞ⧇āĻ–ā§‹āĨ¤

āĻŽāĻžāĻĨāĻž āĻ–āĻžāϟāĻžāĻ“

Bob āĻĒ⧁āϰāύ⧋ āĻāĻ•āϟāĻž āĻĒāϰ⧀āĻ•ā§āώāĻžāϰ āĻĒā§āϰāĻļā§āύ⧇ āĻāχ āϞāĻžāχāύāϟāĻž āĻĒāĻžāϝāĻŧ āφāϰ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧇ āĻāϟāĻž āϕ⧀ āĻ›āĻžāĻĒ⧇āĨ¤

int x = 3;
int y = x++ + ++x;
printf("%d %d\n", x, y);

āĻ¸ā§Ž āωāĻ¤ā§āϤāϰāϟāĻž āϕ⧋āύ⧋ āϏāĻ‚āĻ–ā§āϝāĻž āύāĻžāĨ¤ āϞāĻžāχāύāϟāĻž āϕ⧋āύ āύāĻŋāϝāĻŧāĻŽ āĻ­āĻžāĻ™āϛ⧇ āĻŦāϞ⧋, āφāϰ āϕ⧋āύ āĻĻ⧁āχāϟāĻž āϘāϟāύāĻžāϰ āĻŽāĻžāĻā§‡ āϕ⧋āύ⧋ āĻ•ā§āϰāĻŽ āύ⧇āχ āϤāĻžāϰ āύāĻžāĻŽ āĻŦāϞ⧋āĨ¤ āϤāĻžāϰāĻĒāϰ āĻ•āĻ āĻŋāύ āĻ…āĻ‚āĻļāϟāĻž: āϝ⧇ āĻŽā§‡āĻļāĻŋāύ āϏāĻ¤ā§āϝāĻŋāχ 8 āĻ›āĻžāĻĒ⧇, āϏ⧇āĻ–āĻžāύ⧇āĻ“ "prefix āφāϗ⧇ āϚāϞ⧇, āϤāĻžāχ 8" āωāĻ¤ā§āϤāϰāϟāĻž āϕ⧇āύ āϭ⧁āϞ āϏ⧇āϟāĻž āĻŦā§‹āĻāĻžāĻ“āĨ¤

āĻ“āχ āĻāĻ• expression-āĻ x āĻ•āϤāĻŦāĻžāϰ āĻŦāĻĻāϞāĻžāĻšā§āϛ⧇ āĻ—ā§‹āύ⧋āĨ¤ āϤāĻžāϰāĻĒāϰ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧋ āĻ“āχ āĻŦāĻĻāϞāϗ⧁āϞ⧋āϰ āĻ•ā§āϰāĻŽ āύāĻŋāϝāĻŧ⧇ standard āϕ⧀ āĻ•āĻĨāĻž āĻĻ⧇āϝāĻŧāĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§āϏāĻšāϜ

Maria-āϰ āĻĻā§‹āĻ•āĻžāύ⧇āϰ āĻ–āĻžāϤāĻž āĻĒāĻžāρāϚāϟāĻž āĻŦāĻŋāĻ•ā§āϰāĻŋ āĻāĻ•āϟāĻž āϚāϞāĻŽāĻžāύ āϝ⧋āĻ—āĻĢāϞ⧇ āϝ⧋āĻ— āĻ•āϰ⧇ āφāϰ āĻļ⧇āώ⧇ āϝ⧋āĻ—āĻĢāϞāϟāĻž āĻ›āĻžāĻĒ⧇āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻĒāĻžāρāϚāϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻžāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āϤāĻžāĻĻ⧇āϰ āϝ⧋āĻ—āĻĢāϞāĨ¤

Constraints. āĻĒā§āϰāϤāĻŋāϟāĻž āĻŽāĻžāύ -1000000 āφāϰ 1000000-āϰ āĻŽāĻ§ā§āϝ⧇āĨ¤

Sample. Input 10 20 30 40 50 āĻĻāĻŋāϞ⧇ 150āĨ¤

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    int e = 0;
    scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);

    int total = 0;
    /* Five += lines, one per value. */

    return 0;
}

running-total āύāĻžāĻŽā§‡ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧāĨ¤ total-āϕ⧇ āύāĻŋāĻœā§‡ 0 āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧋; āĻ–āĻžāϞāĻŋ āĻŦāĻžāĻ•ā§āϏ Module 2-āϰ āϏāϤāĻ°ā§āĻ•āĻŦāĻžāĻ°ā§āϤāĻžāĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ⧍āĻŽāĻžāĻāĻžāϰāĻŋ

Zara āĻĻ⧇āĻ–āĻžāϤ⧇ āϚāĻžāϝāĻŧ āϝ⧇ āĻ“ āύāĻž āϚāĻžāϞāĻŋāϝāĻŧ⧇āχ ++ āφāϰ ---āϰ āĻĢāϞ āĻŦāϞ⧇ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻĒāĻĄāĻŧāĻž āĻŽāĻžāύ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇, āĻ āĻŋāĻ• āĻāχ āĻ•ā§āϰāĻŽā§‡āϰ statement-āϗ⧁āϞ⧋āϤ⧇ n-āϰ āĻŽāĻžāύ āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž expression-āϰ āĻŽāĻžāύ āϞ⧇āĻ–ā§‹āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž nāĨ¤

Output. āϚāĻžāϰ āϞāĻžāχāύ: n++-āϰ āĻŽāĻžāύ, āϤāĻžāϰāĻĒāϰ n, āϤāĻžāϰāĻĒāϰ --n, āϤāĻžāϰāĻĒāϰ āφāĻŦāĻžāϰ nāĨ¤

Constraints. -1000 <= n <= 1000āĨ¤

Sample. Input 5 āĻĻāĻŋāϞ⧇ āϚāĻžāϰ āϞāĻžāχāύ 5, 6, 5, 5āĨ¤

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    /* Four printf lines. Each one touches n at most once. */

    return 0;
}

āĻāχ module-āĻ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧ āύāĻžāĨ¤ āϚāĻžāϰāϟāĻž āωāĻ¤ā§āϤāϰ āφāϗ⧇ āĻ•āĻžāĻ—āĻœā§‡ āϞ⧇āĻ–ā§‹, āϤāĻžāϰāĻĒāϰ āϚāĻžāϞāĻžāĻ“āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§ŠāĻ•āĻ āĻŋāύ

Kenji āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–āϛ⧇ āĻ“ āĻĒāϰāĻĒāϰ āĻ•āϝāĻŧ⧇āĻ•āϟāĻž compound assignment-āϰ āĻ•ā§āϰāĻŽ āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻŦā§‹āĻā§‡ āĻ•āĻŋ āύāĻžāĨ¤

āĻĒāĻĄāĻŧāĻž āĻŽāĻžāύ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇, āĻāχ āĻ•ā§āϰāĻŽā§‡ āϚāĻžāϞāĻžāĻ“: *= 3, += 17, /= 4, %= 10āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϧāĻžāĻĒ⧇āϰ āĻĒāϰ⧇āϰ āĻŽāĻžāύ āĻ›āĻžāĻĒā§‹āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž nāĨ¤

Output. āϚāĻžāϰ āϞāĻžāχāύ, āϚāĻžāϰāϟāĻž āϧāĻžāĻĒ⧇āϰ āĻĒāϰ⧇ n-āϰ āĻŽāĻžāύāĨ¤

Constraints. 0 <= n <= 1000000āĨ¤

Sample. Input 9 āĻĻāĻŋāϞ⧇ āϚāĻžāϰ āϞāĻžāχāύ 27, 44, 11, 1āĨ¤

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    /* Four steps, four printf lines, all on the same box. */

    return 0;
}

āĻāχ module-āĻ āĻ—ā§āϰ⧇āĻĄ āĻšāϝāĻŧ āύāĻžāĨ¤ āϤ⧃āϤ⧀āϝāĻŧ āϧāĻžāĻĒ⧇āχ integer division āϚ⧁āĻĒāϚāĻžāĻĒ āĻļ⧇āώ āĻĻ⧁āχāϟāĻž āωāĻ¤ā§āϤāϰ āĻ āĻŋāĻ• āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĨ¤

Run in Compiler

āϏāϚāϰāĻžāϚāϰ āϝ⧇ āĻĒā§āϰāĻļā§āύāϗ⧁āϞ⧋ āφāϏ⧇

  • ++n āĻ•āĻŋ n++-āϰ āĻšā§‡āϝāĻŧ⧇ āĻĻā§āϰ⧁āϤ?

    C-āϤ⧇, āϏāĻžāϧāĻžāϰāĻŖ āĻāĻ•āϟāĻž int-āĻ, āύāĻžāĨ¤ āĻŽāĻžāύāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āύāĻž āĻ•āϰāϞ⧇ compiler āĻāĻ•āχ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻŦāĻžāύāĻžāϝāĻŧāĨ¤ āĻ…āĻ­ā§āϝāĻžāϏāϟāĻž C++-āĻ āϗ⧁āϰ⧁āĻ¤ā§āĻŦ āĻĒāĻžāϝāĻŧ, āϝ⧇āĻ–āĻžāύ⧇ āĻĻ⧁āχ āϰ⧂āĻĒ āφāϞāĻžāĻĻāĻž function āĻĄāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • double-āĻ āĻ•āĻŋ += āϞ⧇āĻ–āĻž āϝāĻžāϝāĻŧ?

    āϝāĻžāϝāĻŧ, āφāϰ āϝ⧇āϕ⧋āύ⧋ arithmetic type-āĻāĨ¤ āĻŦā§āϝāϤāĻŋāĻ•ā§āϰāĻŽ āĻļ⧁āϧ⧁ %=, āĻ•āĻžāϰāĻŖ % āύāĻŋāĻœā§‡āχ floating type āύ⧇āϝāĻŧ āύāĻžāĨ¤

  • total =+ 25 āφāĻĻ⧌ compile āĻšāϝāĻŧ āϕ⧇āύ?

    āĻ•āĻžāϰāĻŖ āĻ“āϟāĻž +25 āĻŽāĻžāύāϟāĻžāϰ āϏāĻžāϧāĻžāϰāĻŖ āĻāĻ•āϟāĻž assignmentāĨ¤ Unary plus āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ āĻāĻ•āϟāĻž operator āϝ⧇āϟāĻž āĻ•āĻŋāϛ⧁āχ āĻ•āϰ⧇ āύāĻž, āϤāĻžāχ C āϕ⧋āύ⧋ āϏāĻŽāĻ¸ā§āϝāĻž āĻĻ⧇āϖ⧇ āύāĻžāĨ¤

  • i = i++ undefined āĻšāϞ⧇ āφāĻŽāĻžāϰ compiler āĻĨāĻžāĻŽā§‡ āύāĻž āϕ⧇āύ?

    āϏāĻžāϧāĻžāϰāĻŖāĻ­āĻžāĻŦ⧇ āĻāϟāĻž āϧāϰāĻž āĻ…āϏāĻŽā§āĻ­āĻŦ, āϤāĻžāχ standard āϕ⧋āύ⧋ āĻŦāĻžāĻ°ā§āϤāĻž āϚāĻžāϝāĻŧ āύāĻžāĨ¤ GCC āϏāĻšāϜ āĻ•ā§āώ⧇āĻ¤ā§āϰāϗ⧁āϞ⧋ -Wall-āĻ āϧāϰ⧇ āφāϰ āĻ•āĻĨāĻžāϟāĻž āϞ⧇āϖ⧇ "may be undefined"āĨ¤

  • a[i] = i++-āĻ“ āĻ•āĻŋ undefined?

    āĻšā§āϝāĻžāρ, āĻāĻ•āχ āĻ•āĻžāϰāϪ⧇āĨ¤ Module 9 array āφāύāĻŦ⧇; āĻ“āĻ–āĻžāύ⧇ āϝ⧇ āύāĻŋāϝāĻŧāĻŽāϟāĻž āϏāĻ™ā§āϗ⧇ āύāĻŋāϝāĻŧ⧇ āϝāĻžāĻŦ⧇ āϏ⧇āϟāĻž āĻāχ lesson-āϰāχāĨ¤

āĻŽā§‚āϞ āĻ•āĻĨāĻž

  • +=, -=, *=, /= āφāϰ %= variable-āϟāĻžāϰ āύāĻžāĻŽ āĻāĻ•āĻŦāĻžāϰ āϞ⧇āϖ⧇ āφāϰ āϜāĻžāϝāĻŧāĻ—āĻžāϤ⧇āχ āĻŦāĻĻāϞāĻžāϝāĻŧāĨ¤
  • Compound assignment āĻĢāϞāϟāĻžāϕ⧇ āĻŦāĻžāρ āĻĒāĻžāĻļ⧇āϰ variable-āϰ type-āĻ āĻĢāĻŋāϰāĻŋāϝāĻŧ⧇ āφāύ⧇, āύ⧀āϰāĻŦ⧇āĨ¤
  • n++ āĻĒ⧁āϰāύ⧋ āĻŽāĻžāύ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ; ++n āύāϤ⧁āύāϟāĻž āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧāĨ¤
  • āĻĻ⧁āχāϟāĻž āϰ⧂āĻĒāχ variable-āϟāĻžāϕ⧇ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āĻŦāĻĻāϞāĻžāϝāĻŧ, āϤāĻžāχ āύāĻŋāĻœā§‡āϰ āϞāĻžāχāύ⧇ āĻ“āϰāĻž āĻāĻ•āĨ¤
  • āĻāĻ• expression-āĻ āĻāĻ•āϟāĻž variable āĻĻ⧁āχāĻŦāĻžāϰ āĻŦāĻĻāϞāĻžāύ⧋ undefined behaviour, āωāĻ¤ā§āϤāϰāϏāĻš āϕ⧋āύ⧋ āϧāĻžāρāϧāĻž āύāĻžāĨ¤
  • āĻāχ track ++ āφāϰ ---āϕ⧇ āύāĻŋāĻœā§‡āϰ statement āĻšāĻŋāϏ⧇āĻŦ⧇ āϞ⧇āϖ⧇āĨ¤

āĻāϰāĻĒāϰ āϤ⧁āĻŽāĻŋ āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž āϛ⧇āĻĄāĻŧ⧇ āϤāĻžāϰ āĻ­āĻŋāϤāϰ⧇āϰ bit-āϗ⧁āϞ⧋ āύāĻŋāϝāĻŧ⧇ āĻ•āĻžāϜ āĻ•āϰāĻŦ⧇, āĻāĻ•āϟāĻž āĻāĻ•āϟāĻž āĻ•āϰ⧇āĨ¤

lesson ā§Š āĻļ⧇āώ

āĻļ⧇āώ āĻšāϞ⧇ āϚāĻŋāĻšā§āύ āĻĻāĻŋāύ, āĻ…āĻ—ā§āϰāĻ—āϤāĻŋ āφāĻĒāύāĻžāϰ āϏāĻžāĻĨ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

āĻĒāϰ⧇āϰāϟāĻž: Bitwise operator: āĻāĻ• āĻŦāĻŋāϟ āĻ•āϰ⧇ āĻ•āĻžāϜ