Module ā§Ē ¡ Operator āĻāϰ type āĻāύāĻāĻžāϰā§āĻļāύ
Assignment-āϰ āĻļāϰā§āĻāĻāĻžāĻ, ++ āĻāϰ --
āĻāĻ 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 āϰā§āĻĒ, āĻāϰ āĻāĻāĻžāϰ āĻŽāĻžāύ āύāϤā§āύāĻāĻžāĨ¤
#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-āϰ āĻāĻŋāϤāϰ⧠āϞā§āĻāĻžāύ⧠āύāĻžāĨ¤
āĻāĻāĻāĻž āĻŦāĻžāĻā§āϏ, āϤāĻŋāύāĻāĻž āϝā§āĻ, āĻļā§āώ⧠āĻāĻāĻŦāĻžāϰ āĻāĻžāĻĒāĻžāĨ¤
#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āĻāĻāĻāĻž āĻāĻŋāĻāĻŋāĻā§āϰ āϞāĻžāĻāύāĨ¤ āϤā§āĻŽāĻžāĻā§ āϝ⧠āύāĻŽā§āĻŦāϰāĻāĻž āĻĻā§āĻāϝāĻŧāĻž āĻšāϝāĻŧ, 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-āĻ āĻ āĻŋāĻ āϰā§āĻĒ: āϤā§āĻŽāĻŋ āύā§āĻāϝāĻŧāĻžāϰ āĻāĻā§ āϝ⧠āĻāĻŋāĻāĻŋāĻāĻāĻž āĻāĻžāϞāĻŋ āĻāĻŋāϞ, āϏā§āĻāĻžāĻ āϤā§āĻŽāĻŋ āĻāĻžāĻāĨ¤
āĻāĻžāϰāĻāĻž āĻŽāĻžāϰā§āĻ āĻĸā§āĻā§, āĻāĻāĻāĻž āϝā§āĻāĻĢāϞ āĻāϰ āĻāĻāĻāĻž āĻāĻŖāύāĻž āĻŦā§āϰā§āϝāĻŧ, āϏāĻŦāĻ 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-āϰ āĻāĻžāĻāĻāĻžāĻ āĻāϰāĻā§āĨ¤
āĻāĻāĻž āĻā§āĻĨāĻžāϝāĻŧ āĻāĻžāĻā§ āϞāĻžāĻā§
- āϤā§āĻŽāĻŋ āϝāϤ loop āϞāĻŋāĻāĻŦā§āĨ¤ āĻāĻāĻāĻž
forheader-āϰ āϤā§āϤā§āϝāĻŧ āĻāϰ⧠āĻĒā§āϰāĻžāϝāĻŧ āϏāĻŦ āϏāĻŽāϝāĻŧ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 āϞā§āĻā§āĨ¤
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-āϰ āϏāϤāϰā§āĻāĻŦāĻžāϰā§āϤāĻžāĨ¤
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 CompilerKenji āĻŽāĻŋāϞāĻŋāϝāĻŧā§ āĻĻā§āĻāĻā§ āĻ āĻĒāϰāĻĒāϰ āĻāϝāĻŧā§āĻāĻāĻž 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: āĻāĻ āĻŦāĻŋāĻ āĻāϰ⧠āĻāĻžāĻ