Learn C Programming

lesson ā§§ / ā§­ ¡ āĻ•āύāĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āϟ, qualifier, āχāύāĻĒ⧁āϟ āφāϰ āφāωāϟāĻĒ⧁āϟ

Module ā§Š ¡ āĻ•āύāĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āϟ, qualifier, āχāύāĻĒ⧁āϟ āφāϰ āφāωāϟāĻĒ⧁āϟ

āĻ•āύāĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āϟ āφāϰ literal: āύāĻžāĻŽ āĻĒāĻžāĻ“āϝāĻŧāĻž āĻŽāĻžāύ

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

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

  • Integer, floating, character āφāϰ string literal āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āĻ āĻŋāĻ• āϝ⧇ type-āϟāĻž āϤ⧁āĻŽāĻŋ āĻšā§‡āϝāĻŧ⧇āĻ›āĻŋāϞ⧇ āϏ⧇āϟāĻž āĻĻāĻŋāϝāĻŧ⧇āĨ¤
  • #define āĻŦāĻž const āĻĻāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž āĻŽāĻžāύāϕ⧇ āύāĻžāĻŽ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āϕ⧋āύāϟāĻž āφāϗ⧇ āϧāϰāϤ⧇ āĻšāϝāĻŧ āϏ⧇āϟāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤
  • Magic number āϚāĻŋāύāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ 010-āϕ⧇ āϝ⧇ āφāϟ āϏ⧇āϟāĻžāχ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

Maria-āϰ āĻĻā§‹āĻ•āĻžāύ⧇āϰ till 7.5 āĻļāϤāĻžāĻ‚āĻļ VAT āύ⧇āϝāĻŧāĨ¤ 7.5 āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻ“āϰ program-āĻ āϞ⧇āĻ–āĻž āφāϛ⧇ āĻāĻ—āĻžāϰ⧋ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧāĨ¤ āϏāϰāĻ•āĻžāϰ āĻšāĻžāϰ āĻŦāĻžāĻĄāĻŧāĻŋāϝāĻŧ⧇ 15 āĻ•āϰāϞ, āĻ“ āĻāĻ—āĻžāϰ⧋āϟāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āĻĻāĻļāϟāĻž āĻŦāĻĻāϞāĻžāϞ, āφāϰ āϤāĻŋāύ āϏāĻĒā§āϤāĻžāĻš āϧāϰ⧇ āĻāĻ•āϰāĻ•āĻŽ receipt āϚ⧁āĻĒāϚāĻžāĻĒ āϭ⧁āϞ āĻ›āĻžāĻĒāĻž āĻšāϞ⧋āĨ¤

āĻāχ āĻ—āĻ˛ā§āĻĒ⧇ āĻ•āĻ āĻŋāύ āϕ⧋āύ⧋ bug āύ⧇āχāĨ¤ āĻāϟāĻž āĻ—ā§‹āĻ›āĻžāύ⧋āϰ āϏāĻŽāĻ¸ā§āϝāĻž, āφāϰ C-āϤ⧇ āĻāϰ āϜāĻ¨ā§āϝ āĻĻ⧁āχāϟāĻž āϜāĻŋāύāĻŋāϏ āφāϛ⧇āĨ¤ āĻāχ lesson āϏ⧇āχāϏāĻŦ āĻŽāĻžāύ āύāĻŋāϝāĻŧ⧇, āϝ⧇āϗ⧁āϞ⧋ āϤ⧁āĻŽāĻŋ āϏ⧋āϜāĻž code-āĻ āϞāĻŋāϖ⧇ āĻĻāĻžāĻ“āĨ¤ āφāϰ āϜāϰ⧁āϰāĻŋ āĻŽāĻžāύāϗ⧁āϞ⧋āϕ⧇ āύāĻžāĻŽ āĻĻ⧇āĻ“āϝāĻŧāĻž āύāĻŋāϝāĻŧ⧇, āϝāĻžāϤ⧇ āĻ“āϟāĻž āĻ•āĻ–āύ⧋ āĻāĻ•āϟāĻžāϰ āĻŦ⧇āĻļāĻŋ āύāĻž āĻšāϝāĻŧāĨ¤

Literal āĻŽāĻžāύ⧇ āύāĻžāĻŽ āĻ›āĻžāĻĄāĻŧāĻž āĻāĻ•āϟāĻž āĻŽāĻžāύ

Program-āĻ āϤ⧁āĻŽāĻŋ āϝāϤ āĻ–āĻžāϞāĻŋ āĻŽāĻžāύ āϞāĻŋāĻ–ā§‹, āĻĒā§āϰāϤāĻŋāϟāĻžāχ āĻāĻ•āϟāĻž literalāĨ¤ int marks = 42;-āϰ 42 āĻāĻ•āϟāĻž integer literalāĨ¤ āϕ⧋āύ⧋ printf-āϰ "Progsity" āĻāĻ•āϟāĻž string literalāĨ¤

Literal-āϰ āĻāĻ•āϟāĻž type āĻĨāĻžāϕ⧇, āϝāĻĻāĻŋāĻ“ āϤ⧁āĻŽāĻŋ āϕ⧋āĻĨāĻžāĻ“ type āϞ⧇āĻ–ā§‹āύāĻŋāĨ¤ Literal-āϟāĻž āϕ⧀āĻ­āĻžāĻŦ⧇ āϞ⧇āĻ–āĻž, āϤāĻž āĻĻ⧇āϖ⧇ compiler type āĻ āĻŋāĻ• āĻ•āϰ⧇, āφāϰ āϏ⧇āχ āĻŦāĻžāĻ›āĻžāχ āϏāĻŦāϏāĻŽāϝāĻŧ āϤ⧋āĻŽāĻžāϰ āĻ­āĻžāĻŦāύāĻžāϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āϞ⧇ āύāĻžāĨ¤

Literal-āϰ āĻĒāϰāĻŋāĻŦāĻžāϰāϗ⧁āϞ⧋, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϝ⧇ type āĻĒāĻžāϝāĻŧ

42            int
42U           unsigned int              U āĻŦāĻž u
42L           long                      L āĻŦāĻž l
42LL          long long                 LL āĻŦāĻž ll
42ULL         unsigned long long        āĻĻ⧁āχāϟāĻž suffix āĻāĻ•āϏāĻžāĻĨ⧇

3.14          double                    āĻĻāĻļāĻŽāĻŋāϕ⧇āϰ āϜāĻ¨ā§āϝ āĻāϟāĻžāχ default
3.14f         float                     f āĻŦāĻž F
3.14L         long double               L āĻŦāĻž l
1.5e3         double, āĻŽāĻžāύ 1500.0        e āĻŽāĻžāύ⧇ āĻĻāĻļ⧇āϰ āϘāĻžāϤ āĻĻāĻŋāϝāĻŧ⧇ āϗ⧁āĻŖ

'A'           int, āĻ­āĻŋāϤāϰ⧇ 65             āĻāĻ•āĻ• āωāĻĻā§āϧ⧃āϤāĻŋāϤ⧇ āĻāĻ•āϟāĻž āĻ…āĻ•ā§āώāϰ
'\n'          int, āĻ­āĻŋāϤāϰ⧇ 10             escape sequence āĻāĻ•āϟāĻžāχ āĻ…āĻ•ā§āώāϰ
"Progsity"    char-āϰ array              āĻœā§‹āĻĄāĻŧāĻž āωāĻĻā§āϧ⧃āϤāĻŋ, āĻĒ⧁āϰ⧋ āφāϞāĻžāĻĻāĻž āϜāĻŋāύāĻŋāϏ

0x1F          int, āĻŽāĻžāύ 31               base 16, 0x prefix
037           int, āĻŽāĻžāύ 31               base 8, āĻļ⧁āϰ⧁āϤ⧇ āĻāĻ•āϟāĻž āĻļā§‚āĻ¨ā§āϝ
0b11111       int, āĻŽāĻžāύ 31               base 2, C23 āĻŦāĻž compiler-āϰ extension
  • Suffix-āϟāĻž literal-āϰ āĻ…āĻ‚āĻļ, āϝ⧇ variable-āĻ āĻ“āϟāĻž āϝāĻžāĻšā§āϛ⧇ āϤāĻžāϰ āĻ…āĻ‚āĻļ āύāĻžāĨ¤
  • 3.14 āĻāĻ•āϟāĻž doubleāĨ¤ āĻ“āϟāĻž float variable-āĻ āϞāĻŋāĻ–āϞ⧇ āϏāϰ⧁ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āϏ⧇āϟāĻž āϚāϞ⧇ āφāϰ āĻ•āĻŋāϛ⧁ āĻ…āĻ™ā§āĻ• āĻšāĻžāϰāĻžāϝāĻŧāĨ¤
  • C-āϤ⧇ character constant āĻāĻ•āϟāĻž int, char āύāĻžāĨ¤ Module 2-āϰ lesson 4 āĻŦāϞ⧇āĻ›āĻŋāϞ āĻ“āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āϕ⧇āύāĨ¤

āϤāĻžāχ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻžāĻœā§‡āϰ āύāĻŋāϝāĻŧāĻŽāϟāĻž āĻšāϞ⧋: āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž āĻŽāĻžāύ⧇ int, āĻĻāĻļāĻŽāĻŋāĻ• āĻŽāĻžāύ⧇ double, āφāϰ āĻ…āĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ āĻŦāϞāϤ⧇ āϚāĻžāχāϞ⧇ suffixāĨ¤

#include <stdio.h>

int main(void)
{
    printf("int literal    : %d\n", 42);
    printf("long long      : %lld\n", 42LL);
    printf("unsigned       : %u\n", 42U);
    printf("double literal : %.2f\n", 3.14);
    printf("float literal  : %.2f\n", 3.14f);
    printf("char literal   : %c and %d\n", 'A', 'A');
    printf("string literal : %s\n", "Progsity");
    return 0;
}
int literal    : 42
long long      : 42
unsigned       : 42
double literal : 3.14
float literal  : 3.14
char literal   : A and 65
string literal : Progsity

āϏāĻžāϤāϟāĻž literal, āϏāĻžāϤāϟāĻž specifier, āĻāĻ•āϟāĻž programāĨ¤ āĻ›āϝāĻŧ āύāĻŽā§āĻŦāϰ āϞāĻžāχāύāϟāĻž āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋: āĻāĻ•āϟāĻžāχ literal, āĻĻ⧁āχāĻŦāĻžāϰ āĻ›āĻžāĻĒāĻž, āĻāĻ•āĻŦāĻžāϰ āĻšā§‡āĻšāĻžāϰāĻž āĻšāĻŋāϏ⧇āĻŦ⧇ āφāϰ āĻāĻ•āĻŦāĻžāϰ āĻ­āĻŋāϤāϰ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻž āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤

āĻļ⧁āϰ⧁āϤ⧇ āĻļā§‚āĻ¨ā§āϝ āĻŽāĻžāύ⧇ base āφāϟ

āĻāĻ•āχ āϏāĻ‚āĻ–ā§āϝāĻž C-āϤ⧇ āϚāĻžāϰ āĻ­āĻžāĻŦ⧇ āϞ⧇āĻ–āĻž āϝāĻžāϝāĻŧāĨ¤ Base 10 āϏāĻžāϧāĻžāϰāĻŖāϟāĻžāĨ¤ Base 16 āĻļ⧁āϰ⧁ āĻšāϝāĻŧ 0x āĻĻāĻŋāϝāĻŧ⧇, base 8 āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āĻāĻ•āϟāĻž 0 āĻĻāĻŋāϝāĻŧ⧇, āφāϰ base 2 āĻļ⧁āϰ⧁ āĻšāϝāĻŧ 0b āĻĻāĻŋāϝāĻŧ⧇āĨ¤

āĻāϰ āϤāĻŋāύāϟāĻž āύāĻŋāϰ⧀āĻšāĨ¤ āϚāĻžāϰ āύāĻŽā§āĻŦāϰāϟāĻž āĻ­āĻžāώāĻžāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĒ⧁āϰāύ⧋ āĻĢāĻžāρāĻĻ, āĻ•āĻžāϰāĻŖ āĻļ⧁āϰ⧁āϤ⧇ āĻļā§‚āĻ¨ā§āϝ āĻŦāϏāĻžāύ⧋ āĻŽāĻžāύ⧁āώ āϏ⧌āĻ¨ā§āĻĻāĻ°ā§āϝ⧇āϰ āϜāĻ¨ā§āϝāχ āĻ•āϰ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    int plain = 31;
    int hex = 0x1F;
    int octal = 037;
    int looks_like_ten = 010;

    printf("31   is %d\n", plain);
    printf("0x1F is %d\n", hex);
    printf("037  is %d\n", octal);
    printf("010  is %d\n", looks_like_ten);
    return 0;
}
31   is 31
0x1F is 31
037  is 31
010  is 8

āĻĒā§āϰāĻĨāĻŽ āϤāĻŋāύ āϞāĻžāχāύ āĻāĻ•āχ āĻŽāĻžāύ, āϤāĻŋāύ āĻ­āĻžāĻŦ⧇ āϞ⧇āĻ–āĻžāĨ¤ āϚāĻžāϰ āύāĻŽā§āĻŦāϰāϟāĻž āĻāĻŽāύ āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āϝ⧇āϟāĻž āϕ⧇āω āχāĻšā§āϛ⧇ āĻ•āϰ⧇ āϞ⧇āϖ⧇āύāĻŋāĨ¤

āϕ⧇āω āϝāĻĻāĻŋ product code-āϰ āϤāĻžāϞāĻŋāĻ•āĻž 001, 007, 010 āϞ⧇āϖ⧇, āĻ“ āĻĒāĻžāϝāĻŧ 1, 7 āφāϰ 8āĨ¤ Compiler āĻĻ⧁āχ command line-āϰ āϕ⧋āύ⧋āϟāĻžāϤ⧇āχ āĻ•āĻŋāϛ⧁ āĻŦāϞ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ āϤāĻŋāύāϟāĻžāχ āĻŦ⧈āϧ octalāĨ¤

Base 2 āϤ⧁āϞāύāĻžāϝāĻŧ āύāϤ⧁āύāĨ¤ 0b11111 āĻŦāĻšā§ āĻŦāĻ›āϰ āϧāϰ⧇ GCC-āϰ extension, āφāϰ standard C-āϤ⧇ āĻĸ⧁āϕ⧇āϛ⧇ C23-āϤ⧇, āϤāĻžāχ bit-āϰ āύāĻ•āĻļāĻž āϜāϰ⧁āϰāĻŋ āĻšāϞ⧇ āĻāχ track hex āϞ⧇āϖ⧇āĨ¤

āϤāĻžāχ āύāĻŋāϝāĻŧāĻŽāϟāĻž āĻšāϞ⧋: C-āϤ⧇ āĻļ⧁āϰ⧁āϰ āĻļā§‚āĻ¨ā§āϝ āĻ•āĻ–āύ⧋ āϏāĻžāϜāϏāĻœā§āϜāĻž āύāĻž, āφāϰ āϏāĻžāϰāĻŋ āĻŽā§‡āϞāĻžāϤ⧇ āϚāĻžāχāϞ⧇ printf-āĻ width āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧋āĨ¤

āϚāĻžāϰāϟāĻž literal āĻĒāϰāĻŋāĻŦāĻžāϰ, āφāϰ integer āϞ⧇āĻ–āĻžāϰ āϚāĻžāϰāϟāĻž āĻĒāĻĨ āϤ⧁āĻŽāĻŋ āϝāϤ āĻ–āĻžāϞāĻŋ āĻŽāĻžāύ āϞāĻŋāĻ–ā§‹, āĻĒā§āϰāϤāĻŋāϟāĻž āĻāĻĻ⧇āϰ āĻāĻ•āϟāĻž literal integer floating character string 3.14 3.14f 1.5e3 'A' '7' '\n' "Progsity" 31 0x1F 037 base 10 base 16 base 8 āωāĻĒāϰ⧇āϰ āϤāĻŋāύāϟāĻž integer-āχ āĻāĻ•āχ āĻŽāĻžāύāĨ¤ āϕ⧇āĻŦāϞ āϞ⧇āĻ–āĻžāϟāĻž āĻŦāĻĻāϞ⧇āϛ⧇, āφāϰ āϕ⧇āĻŦāϞ base 8-āϰ āϚāĻŋāĻšā§āύāϟāĻžāχ āĻāĻŽāύ āϜāĻŋāύāĻŋāϏ āϝ⧇āϟāĻž āĻŽāĻžāύ⧁āώ āĻ—ā§‹āĻ›āĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āύāĻŋāĻœā§‡āχ āĻŦāϏāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤
Figure 1. Literal-āϰ āĻĒāϰāĻŋāĻŦāĻžāϰāϗ⧁āϞ⧋āĨ¤ āĻŦāĻŋāĻĒāĻœā§āϜāύāĻ• āĻĄāĻžāϞāϟāĻž āϏ⧇āϟāĻžāχ, āϝāĻžāϰ āϚāĻŋāĻšā§āύ āĻļ⧁āϰ⧁āϤ⧇ āĻŦāϏāĻžāύ⧋ āĻāĻ•āϟāĻžāĻŽāĻžāĻ¤ā§āϰ āĻļā§‚āĻ¨ā§āϝāĨ¤

#define āĻŽāĻžāύ⧇ compiler āĻĻ⧇āĻ–āĻžāϰ āφāϗ⧇āχ āϖ⧁āρāĻœā§‡ āĻŦāĻĻāϞ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž

āĻāĻ•āϟāĻž #define āĻšāϞ⧋ preprocessor-āϰ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāĨ¤ Preprocessor compiler-āϰ āφāϗ⧇ āϚāϞ⧇, āϤ⧋āĻŽāĻžāϰ file-āϟāĻž āϞ⧇āĻ–āĻž āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧ⧇, āφāϰ āύāĻžāĻŽāϟāĻž āϝ⧇āĻ–āĻžāύ⧇ āϝ⧇āĻ–āĻžāύ⧇ āφāϛ⧇ āϏāĻŦ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻŦāĻĻāϞāĻŋ āĻŦāϏāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤

āĻāϰ type āύ⧇āχ, semicolon āϞāĻžāϗ⧇ āύāĻž, āφāϰ compiler āĻļ⧁āϰ⧁ āĻšāĻ“āϝāĻŧāĻžāϰ āφāϗ⧇āχ āĻāϟāĻž āĻšāĻžāĻ“āϝāĻŧāĻžāĨ¤ āĻāϟāĻžāχ āĻāϰ āĻœā§‹āϰ, āφāϰ āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻŽāĻ¸ā§āϝāĻžāĻ“ āĻāĻ–āĻžāύ āĻĨ⧇āϕ⧇āχāĨ¤

#include <stdio.h>

#define VAT_PERCENT 15
#define SHOP_NAME "Maria General Store"

int main(void)
{
    long long bill_paisa = 36000;

    printf("%s\n", SHOP_NAME);
    printf("VAT is %d percent\n", VAT_PERCENT);
    printf("VAT on 360.00 is %lld paisa\n", bill_paisa * VAT_PERCENT / 100);
    return 0;
}
Maria General Store
VAT is 15 percent
VAT on 360.00 is 5400 paisa

Compiler āϝāĻ–āύ āĻ“āχ program āĻĒāĻĄāĻŧ⧇, VAT_PERCENT āĻļāĻŦā§āĻĻāϟāĻžāϰ āφāϰ āĻ…āĻ¸ā§āϤāĻŋāĻ¤ā§āĻŦāχ āύ⧇āχāĨ¤ āĻ“ āĻĻ⧁āχ āϜāĻžāϝāĻŧāĻ—āĻžāϤ⧇āχ 15 āĻ…āĻ™ā§āĻ•āϗ⧁āϞ⧋ āĻĻ⧇āϖ⧇, āĻ āĻŋāĻ• āϝ⧇āύ Maria āύāĻŋāĻœā§‡ āϞāĻŋāϖ⧇ āĻĻāĻŋāϝāĻŧ⧇āϛ⧇āĨ¤

āĻŦāĻĻāϞāϟāĻž āϝ⧇āĻšā§‡āϤ⧁ āϞ⧇āĻ–āĻžāϰ āĻ¸ā§āϤāϰ⧇, āĻāĻ•āϟāĻž macro-āϰ āϕ⧋āύ⧋ scope-āĻ“ āύ⧇āχāĨ¤ File-āϰ āĻŽāĻžāĻĨāĻžāϝāĻŧ āĻŦāϏāĻžāύ⧋ #define file-āϰ āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϚāĻžāϞ⧁ āĻĨāĻžāϕ⧇āĨ¤ āĻ“āϟāĻž function-āϰ āĻ­āĻŋāϤāϰ⧇, declaration-āϰ āĻ­āĻŋāϤāϰ⧇, āφāϰ āύāĻžāĻŽāϟāĻž āϝ⧇āĻ–āĻžāύ⧇āχ āĻĨāĻžāϕ⧇ āϏ⧇āĻ–āĻžāύ⧇āχ āĻŦāĻĻāϞāĻŋ āĻŦāϏāĻžāĻŦ⧇āĨ¤

Const āĻŽāĻžāύ⧇ āĻāĻŽāύ variable āϝ⧇āϟāĻž compiler āĻŦāĻĻāϞāĻžāϤ⧇ āĻĻ⧇āϝāĻŧ āύāĻž

const āĻšāϞ⧋ āϏāĻžāϧāĻžāϰāĻŖ āĻāĻ•āϟāĻž variable, āϏāĻžāĻĨ⧇ āĻŦāĻžāĻĄāĻŧāϤāĻŋ āĻāĻ•āϟāĻž āĻļāĻŦā§āĻĻāĨ¤ āĻāϰ type āφāϛ⧇, āĻāϟāĻž memory-āϤ⧇ āĻĨāĻžāϕ⧇, āφāϰ āϝ⧇ scope-āĻ declare āĻšāϝāĻŧ⧇āϛ⧇ āϏ⧇āϟāĻžāχ āĻŽāĻžāύ⧇āĨ¤ āĻāϤ⧇ assign āĻ•āϰāϞ⧇ compiler error āĻĻ⧇āϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    const double PI = 3.14159265358979;
    const int SEATS_PER_ROW = 8;

    double radius = 2.5;

    printf("area of the mat  : %.2f\n", PI * radius * radius);
    printf("seats in 12 rows : %d\n", SEATS_PER_ROW * 12);
    return 0;
}
area of the mat  : 19.63
seats in 12 rows : 96

āĻĻ⧁āχāϟāĻž constant-āχ āĻ•āĻžāĻœā§‡ āϞ⧇āϗ⧇āϛ⧇ āφāϰ āϕ⧋āύ⧋āϟāĻžāχ āĻŦāĻĻāϞāĻžāϝāĻŧāύāĻŋāĨ¤ āĻāĻĻ⧇āϰ āύāĻŋāĻšā§‡ āϝ⧇āϕ⧋āύ⧋ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ PI = 3.0; āϞāĻžāχāύāϟāĻž āĻŦāϏāĻžāĻ“, program āφāϰ build āĻšāĻŦ⧇ āύāĻž, āφāϰ const-āϰ āĻĒ⧁āϰ⧋ āĻ•āĻžāϜāϟāĻžāχ āĻāϟ⧁āϕ⧁āĨ¤

āĻ āĻŋāĻ• āϕ⧋āύ āĻ•āĻĨāĻžāϟāĻž compiler āĻŦāϞ⧇, āφāϰ āĻ“ āφāϰ āϕ⧀ āϕ⧀ āĻŽāĻžāύāĻž āĻ•āϰāϤ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇, āϏ⧇āϟāĻž āĻĒāϰ⧇āϰ lessonāĨ¤ āĻāĻ–āĻžāύ⧇ āĻ•āĻĨāĻžāϟāĻž āϛ⧋āϟ: const āĻšāϞ⧋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āϞāĻžāĻ—āĻžāύ⧋ āĻāĻ•āϟāĻž variable, āφāϰ #define variable-āχ āύāĻžāĨ¤

Const āύāĻž #define, āφāϰ āϕ⧋āύāϟāĻž āφāϗ⧇

āφāϗ⧇ const āϧāϰ⧋āĨ¤ #define āϧāϰ⧋ āϤāĻ–āύāχ, āϝāĻ–āύ āĻāĻŽāύ āĻ•āĻŋāϛ⧁ āĻĻāϰāĻ•āĻžāϰ āϝ⧇āϟāĻž variable āĻšāϝāĻŧ⧇ āĻ“āĻ āĻž āϏāĻŽā§āĻ­āĻŦ āύāĻžāĨ¤

āĻĒā§āϰāĻļā§āύconst#define
āϕ⧇ āϏāĻžāĻŽāϞāĻžāϝāĻŧcompilerpreprocessor, compiler-āϰ āφāϗ⧇
type āφāϛ⧇ āĻ•āĻŋāφāϛ⧇āύ⧇āχ, āĻ“āϟāĻž āϞ⧇āĻ–āĻž
type āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–āĻž āĻšāϝāĻŧ āĻ•āĻŋāĻšāϝāĻŧāĻŽā§‡āϞāĻžāύ⧋āϰ āĻ•āĻŋāϛ⧁ āύ⧇āχ
āĻāĻ•āϟāĻž block-āĻ āφāϟāĻ•āĻžāύ⧋ āϝāĻžāϝāĻŧ āĻ•āĻŋāϝāĻžāϝāĻŧāϝāĻžāϝāĻŧ āύāĻž, āĻ“āχ āϞāĻžāχāύ āĻĨ⧇āϕ⧇ āĻ—ā§‹āϟāĻž file
debugger-āĻ āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ āĻ•āĻŋāϝāĻžāϝāĻŧ, āύāĻžāĻŽ āϧāϰ⧇āϝāĻžāϝāĻŧ āύāĻž, āφāϗ⧇āχ āĻŦāĻĻāϞ⧇ āϗ⧇āϛ⧇
array-āϰ āĻŽāĻžāĻĒ āĻšāĻŋāϏ⧇āĻŦ⧇ āϚāϞ⧇ āĻ•āĻŋāϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ constant āĻšāĻŋāϏ⧇āĻŦ⧇ āύāĻž, āύāĻŋāĻšā§‡ āĻĻ⧇āĻ–ā§‹āϚāϞ⧇
semicolon āϞāĻžāϗ⧇ āĻ•āĻŋāϞāĻžāϗ⧇āϞāĻžāϗ⧇ āύāĻž, āφāϰ āĻĻāĻŋāϞ⧇ āϏ⧇āϟāĻžāĻ“ āĻŦāĻĻāϞāĻŋ āĻšāϝāĻŧ⧇ āĻĸā§‹āϕ⧇

Array-āϰ āĻŽāĻžāĻĒ⧇āϰ āϏāĻžāϰāĻŋāϟāĻžāχ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ āĻĢāĻžāρāĻ•āĨ¤ C-āϤ⧇ āĻāĻ•āϟāĻž const int āĻšāϞ⧋ āĻāĻŽāύ variable āϝ⧇āϟāĻž āϤ⧁āĻŽāĻŋ āĻŦāĻĻāϞāĻžāĻŦ⧇ āύāĻž āĻŦāϞ⧇ āĻ•āĻĨāĻž āĻĻāĻŋāϝāĻŧ⧇āĻ›, āφāϰ āĻ“āϟāĻž constant expression āύāĻžāĨ¤

āĻāĻ•āϟāĻž const int limit āĻĻāĻŋāϝāĻŧ⧇ int marks[limit]; āϞāĻŋāĻ–āϞ⧇ C17-āϤ⧇ āϏ⧇āϟāĻž build āĻšāϝāĻŧ, āϤāĻŦ⧇ āϤ⧁āĻŽāĻŋ āĻāĻ•āϟāĻž variable length array āĻŦāĻžāύāĻŋāϝāĻŧ⧇ āĻĢ⧇āϞ⧇āĻ›, āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŽāĻžāĻĒ⧇āϰ array āύāĻžāĨ¤ āĻ“āϟāĻžāϰ āĻŽāĻžāύ⧇ āϕ⧀ āφāϰ āĻ•āĻ–āύ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ, āϏ⧇āϟāĻž Module 9 āĻŦāϞ⧇āĨ¤

C++-āĻ āĻ“āχ āĻāĻ•āχ āϞāĻžāχāύ āϏāĻžāϧāĻžāϰāĻŖ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŽāĻžāĻĒ⧇āϰ array, āφāϰ āĻāχ āĻ•āĻžāϰāϪ⧇āχ C++-āϰ āϕ⧋āύ⧋ āĻĒāĻžāϤāĻž āĻĨ⧇āϕ⧇ āϤ⧁āϞ⧇ āφāύāĻž āĻĒāϰāĻžāĻŽāĻ°ā§āĻļ āĻāĻ–āĻžāύ⧇ āϚ⧁āĻĒāϚāĻžāĻĒ āϭ⧁āϞ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Enum, āĻāĻ• āĻ…āύ⧁āĻšā§āϛ⧇āĻĻ⧇

āϏāĻ‚āĻ–ā§āϝāĻžāϕ⧇ āύāĻžāĻŽ āĻĻ⧇āĻ“āϝāĻŧāĻžāϰ āϤ⧃āϤ⧀āϝāĻŧ āĻāĻ•āϟāĻž āĻĒāĻĨ āφāϛ⧇, āφāϰ āĻāĻ•āϟāĻž āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āϏ⧇āĻŸā§‡āϰ āϜāĻ¨ā§āϝ āϏ⧇āϟāĻžāχ āĻ āĻŋāĻ• āĻĒāĻĨāĨ¤ āĻāĻ•āϟāĻž enum āĻĒāϰāĻĒāϰ āĻ•āϤāϗ⧁āϞ⧋ āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻžāϕ⧇ āĻĒāĻĄāĻŧāĻžāϰ āĻŽāϤ⧋ āύāĻžāĻŽ āĻĻ⧇āϝāĻŧ, 0 āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇ āωāĻĒāϰ⧇ āĻ“āϠ⧇, āϝāĻĻāĻŋ āύāĻž āϤ⧁āĻŽāĻŋ āĻ…āĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ āĻŦāϞ⧋āĨ¤

#include <stdio.h>

int main(void)
{
    enum status { pending, running, passed, failed };
    enum status verdict = passed;

    printf("verdict = %d\n", verdict);
    return 0;
}
verdict = 2

const int-āϰ āĻŽāϤ⧋ āύāĻž, enum-āϰ āύāĻžāĻŽ āϏāĻ¤ā§āϝāĻŋāχ āĻāĻ•āϟāĻž constant expression, āϤāĻžāχ āĻ“āϟāĻž āĻĻāĻŋāϝāĻŧ⧇ array-āϰ āĻŽāĻžāĻĒ āĻĻ⧇āĻ“āϝāĻŧāĻž āϝāĻžāϝāĻŧāĨ¤ Module 12 struct-āϰ āĻĒāĻžāĻļ⧇ āĻāϟāĻž āύāĻŋāϝāĻŧ⧇ āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻ•āĻžāϜ āĻ•āϰ⧇, āφāϰ āϤāϤāĻ•ā§āώāĻŖ āĻāϟāĻžāϕ⧇ āĻāĻ•āϟāĻž āĻāϞāĻ• āĻšāĻŋāϏ⧇āĻŦ⧇āχ āύāĻžāĻ“āĨ¤

Magic number āĻŽāĻžāύ⧇ āϝ⧇ āϏāĻ‚āĻ–ā§āϝāĻž āϕ⧇āω āĻŦā§āϝāĻžāĻ–ā§āϝāĻž āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž

Magic number āĻšāϞ⧋ āĻšāĻŋāϏāĻžāĻŦ⧇āϰ āĻŽāĻžāĻāĻ–āĻžāύ⧇ āĻŦāϏāĻž āĻ–āĻžāϞāĻŋ āĻāĻ•āϟāĻž literal, āϝāĻžāϰ āĻŽāĻžāύ⧇ āϕ⧇āĻŦāϞ āϞ⧇āĻ–āϕ⧇āϰ āĻŽāĻžāĻĨāĻžāϝāĻŧ āĻĨāĻžāϕ⧇āĨ¤ āĻ›āϝāĻŧ āĻŽāĻžāϏ āĻĒāϰ⧇ āϞ⧇āĻ–āĻ• āύāĻŋāĻœā§‡āχ āĻ…āĻ¨ā§āϝ āĻāĻ•āϜāύ āĻŽāĻžāύ⧁āώāĨ¤

āύāĻŋāĻšā§‡ Maria-āϰ till, āĻĒā§āϰāĻĨāĻŽā§‡ āϝ⧇āĻ­āĻžāĻŦ⧇ āĻ“ āϞāĻŋāϖ⧇āĻ›āĻŋāϞ, āϤāĻžāϰāĻĒāϰ āύāĻžāĻŽ āĻĻāĻŋāϝāĻŧ⧇ āφāĻŦāĻžāϰ āϞ⧇āĻ–āĻžāĨ¤ āĻĻ⧁āχāϟāĻž program āĻāĻ•āχ byte āĻ›āĻžāĻĒ⧇āĨ¤

Example 1: magic number āĻĻāĻŋāϝāĻŧ⧇ āϞ⧇āĻ–āĻž till

āĻāĻ–āĻžāύāĻ•āĻžāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āĻ āĻŋāĻ•āĨ¤ āϞāĻžāχāύāϟāĻžāϰ āĻŦāĻžāĻ•āĻŋāϟāĻž āύāĻž āĻĒāĻĄāĻŧ⧇ āĻ•āĻžāωāϕ⧇ āĻŦā§‹āĻāĻžāĻ“ āϤ⧋, 75 āφāϰ 1000 āϜāĻŋāύāĻŋāϏ āĻĻ⧁āχāϟāĻž āϕ⧀āĨ¤

#include <stdio.h>

int main(void)
{
    long long rice = 12000;
    long long oil = 45000;

    printf("Rice  : %lld\n", rice + rice * 75 / 1000);
    printf("Oil   : %lld\n", oil + oil * 75 / 1000);
    printf("Total : %lld\n", rice + oil + (rice + oil) * 75 / 1000);
    return 0;
}
Rice  : 12900
Oil   : 48375
Total : 61275

āĻšāĻžāϰāϟāĻž āϤāĻŋāύāĻŦāĻžāϰ āφāϛ⧇āĨ¤ āĻ“āϟāĻž āĻŦāĻĻāϞāĻžāύ⧋ āĻŽāĻžāύ⧇ āϤāĻŋāύāϟāĻž edit, āφāϰ āĻĻ⧁āχāϟāĻž āĻ•āϰ⧇ āĻĨ⧇āĻŽā§‡ āϗ⧇āϞ⧇ compiler āϤ⧋āĻŽāĻžāϕ⧇ āϏ⧇āϟāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āύāĻžāĨ¤

Run in Compiler
Example 2: āϏ⧇āχ āĻāĻ•āχ till, āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋āϕ⧇ āύāĻžāĻŽ āĻĻāĻŋāϝāĻŧ⧇

āĻĻ⧁āχāϟāĻž declaration, āφāϰ āĻšāĻžāϰāϟāĻž āĻāĻ–āύ āĻ āĻŋāĻ• āĻāĻ• āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻĨāĻžāϕ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    const long long VAT_PER_MILLE = 75;
    const long long PER_MILLE = 1000;

    long long rice = 12000;
    long long oil = 45000;
    long long both = rice + oil;

    printf("Rice  : %lld\n", rice + rice * VAT_PER_MILLE / PER_MILLE);
    printf("Oil   : %lld\n", oil + oil * VAT_PER_MILLE / PER_MILLE);
    printf("Total : %lld\n", both + both * VAT_PER_MILLE / PER_MILLE);
    return 0;
}
Rice  : 12900
Oil   : 48375
Total : 61275

Byte āϧāϰ⧇ āϧāϰ⧇ āĻāĻ•āχ outputāĨ¤ āĻŽā§‡āĻļāĻŋāύ⧇āϰ āĻ•āĻŋāϛ⧁ āϞāĻžāĻ­ āĻšāϞ⧋ āύāĻž āφāϰ āĻĒāϰ⧇āϰ āĻĒāĻžāĻ āϕ⧇āϰ āϏāĻŦāϟ⧁āϕ⧁ āϞāĻžāĻ­ āĻšāϞ⧋āĨ¤

āĻļāϤāĻžāĻ‚āĻļ āύāĻž āĻŦāϞ⧇ āĻšāĻžāϜāĻžāϰāĻžāĻ‚āĻļ, āĻ•āĻžāϰāĻŖ 7.5 āĻļāϤāĻžāĻ‚āĻļ āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž āύāĻž āφāϰ āĻāχ till āϏāĻŦāĻ•āĻŋāϛ⧁ āĻĒā§‚āĻ°ā§āĻŖ āĻāĻ•āϕ⧇ āϰāĻžāϖ⧇āĨ¤ āϕ⧇āύ, āϏ⧇āϟāĻž Module 2-āϰ lesson 3āĨ¤

Run in Compiler
Example 3: āĻāĻ• program-āĻ āĻĻ⧁āχāϟāĻžāχ, āϝ⧇āϟāĻž āϤ⧁āĻŽāĻŋ āϏāĻ¤ā§āϝāĻŋāχ āϞāĻŋāĻ–āϤ⧇

āϝ⧇āϟāĻž āĻ•āĻ–āύ⧋āχ āϏāĻ‚āĻ–ā§āϝāĻž āύāĻž āϤāĻžāϰ āϜāĻ¨ā§āϝ #define, āφāϰ āϝāĻž āϝāĻž āϏāĻ‚āĻ–ā§āϝāĻž āϤāĻžāϰ āϜāĻ¨ā§āϝ constāĨ¤

#include <stdio.h>

#define SHOP_NAME "Maria General Store"

int main(void)
{
    const long long VAT_PER_MILLE = 75;
    const long long PER_MILLE = 1000;
    const long long PAISA_PER_TAKA = 100;

    long long bill = 57000;
    long long vat = bill * VAT_PER_MILLE / PER_MILLE;
    long long total = bill + vat;

    printf("%s\n", SHOP_NAME);
    printf("bill  : %lld.%02lld\n", bill / PAISA_PER_TAKA, bill % PAISA_PER_TAKA);
    printf("vat   : %lld.%02lld\n", vat / PAISA_PER_TAKA, vat % PAISA_PER_TAKA);
    printf("total : %lld.%02lld\n", total / PAISA_PER_TAKA, total % PAISA_PER_TAKA);
    return 0;
}
Maria General Store
bill  : 570.00
vat   : 42.75
total : 612.75

āĻļ⧇āώ āϤāĻŋāύ āϞāĻžāχāύ⧇āϰ % āĻšāϞ⧋ āĻ­āĻžāĻ—āĻļ⧇āώ⧇āϰ operator, āφāϰ Module 4 āĻ“āϟāĻž āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻļ⧇āĻ–āĻžāϝāĻŧāĨ¤ āĻ“āϟāĻž āĻāĻ–āĻžāύ⧇ āφāϛ⧇ āĻ•āĻžāϰāĻŖ receipt-āχ āĻ“āϰ āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ• āϜāĻžāϝāĻŧāĻ—āĻž, āφāϰ Module 4 āĻĻ⧁āχ lesson āĻĻā§‚āϰ⧇āĨ¤

Run in Compiler

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

  • āϝ⧇ standard library āϤ⧁āĻŽāĻŋ āĻāĻ–āύāχ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻ›āĨ¤ BUFSIZ, EOF āφāϰ NULL āĻšāϞ⧋ <stdio.h>-āϰ macroāĨ¤ Module 3-āϰ lesson 5-āĻ āϝāĻ–āύ EOF āϞāĻŋāĻ–āĻŦ⧇, compiler āĻĻ⧇āĻ–āĻžāϰ āφāϗ⧇āχ preprocessor āϏ⧇āĻ–āĻžāύ⧇ -1 āĻŦāϏāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻŦ⧇āĨ¤
  • Linux-āϰ file permissionāĨ¤ chmod 0755-āϰ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āĻāĻ•āϟāĻž octal literal, āφāϰ āĻāϰ āĻĒāĻŋāĻ›āύ⧇āϰ C call āĻ“āχ āĻāĻ•āχ āϏāĻ‚āĻ–ā§āϝāĻž āύ⧇āϝāĻŧāĨ¤ āĻ“āĻ–āĻžāύ⧇ āĻļ⧁āϰ⧁āϰ āĻļā§‚āĻ¨ā§āϝāϟāĻž āχāĻšā§āĻ›āĻžāĻ•ā§ƒāϤ āφāϰ āϜāϰ⧁āϰāĻŋ, āφāϰ āĻ āĻŋāĻ• āĻāχ āĻ•āĻžāϰāϪ⧇āχ C āĻ“āĻ­āĻžāĻŦ⧇ āĻĒāĻĄāĻŧ⧇āĨ¤
  • Graphics program-āĻ āϰāĻ™āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž game engine āφāϰ image tool āϰāĻ™ āϞ⧇āϖ⧇ 0xFF8800 āĻ­āĻžāĻŦ⧇, āĻ•āĻžāϰāĻŖ hex-āϰ āĻĒā§āϰāϤāĻŋ āĻœā§‹āĻĄāĻŧāĻž āĻ…āĻ™ā§āĻ• āϞāĻžāϞ, āϏāĻŦ⧁āϜ āĻŦāĻž āύ⧀āϞ⧇āϰ āĻāĻ• byteāĨ¤ Decimal-āĻ āĻ“āχ āĻ—āĻĄāĻŧāύāϟāĻž āϚāĻžāĻĒāĻž āĻĒāĻĄāĻŧ⧇ āϝ⧇āϤāĨ¤
  • Payroll-āϰ batch jobāĨ¤ āĻ•āϰ⧇āϰ āϧāĻžāĻĒ, āĻšāĻŋāϏāĻžāĻŦ āĻ—ā§‹āϞ āĻ•āϰāĻžāϰ āĻāĻ•āĻ• āφāϰ āĻŦ⧇āϤāύ⧇āϰ āϏāĻŽāϝāĻŧāϏ⧀āĻŽāĻž āĻāĻ•āϟāĻž file-āϰ āĻŽāĻžāĻĨāĻžāϝāĻŧ āύāĻžāĻŽ āĻĻ⧇āĻ“āϝāĻŧāĻž constant āĻšāϝāĻŧ⧇ āĻŦāϏ⧇ āĻĨāĻžāϕ⧇āĨ¤ āϤāĻžāϤ⧇ āĻŦāĻ›āϰ⧇āϰ āύāĻŋāϝāĻŧāĻŽ āĻŦāĻĻāϞ āĻāĻ•āϟāĻžāĻŽāĻžāĻ¤ā§āϰ edit, āϝ⧇āϟāĻž reviewer āĻšā§‹āϖ⧇ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāϝāĻŧāĨ¤

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

ā§§. āĻ—ā§‹āĻ›āĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āφāϗ⧇ āĻļā§‚āĻ¨ā§āϝ āĻŦāϏāĻžāύ⧋āĨ¤

int product_code = 010;
printf("%d\n", product_code);

āĻĻ⧁āχ command line-āϰ āϕ⧋āύ⧋āϟāĻžāϤ⧇āχ āĻ•āĻŋāϛ⧁ āĻŦāϞ⧇ āύāĻž, āφāϰ āĻ›āĻžāĻĒ⧇ 8āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āĻ…āĻ™ā§āĻ•āχ āĻŦ⧈āϧ octal, āϤāĻžāχ compiler-āϰ āφāĻĒāĻ¤ā§āϤāĻŋ āĻ•āϰāĻžāϰ āĻ•āĻŋāϛ⧁ āύ⧇āχāĨ¤ Code-āϟāĻž āĻ›āĻžāĻĒāĻžāϰ āϏāĻŽāϝāĻŧ 010 āĻĻ⧇āĻ–āĻžāϤ⧇ āϚāĻžāχāϞ⧇ āϏ⧇āϟāĻž printf-āϰ width āφāϰ zero flag-āϰ āĻ•āĻžāϜ, āφāϰ āĻāχ module-āϰ lesson 3-āĻ āϏ⧇āϗ⧁āϞ⧋ āĻĒāĻžāĻŦ⧇āĨ¤

⧍. #define-āϰ āĻļ⧇āώ⧇ semicolon āĻĻ⧇āĻ“āϝāĻŧāĻžāĨ¤

#define PI 3.14159;

double area = PI * 2.0 * 2.0;

Playground-āϰ GCC 12 āĻŦāϞ⧇ error: invalid type argument of unary '*' (have 'double'), āφāϰ āϝ⧇ āϞāĻžāχāύāϟāĻž āĻĻ⧇āĻ–āĻžāϝāĻŧ āϏ⧇āϟāĻž PI āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āϞāĻžāχāύ, āϝ⧇ āϞāĻžāχāύ⧇ define āĻšāϝāĻŧ⧇āϛ⧇ āϏ⧇āϟāĻž āύāĻžāĨ¤ Semicolon-āϟāĻžāĻ“ āĻŦāĻĻāϞāĻŋ āĻšāϝāĻŧ⧇ āĻĸ⧁āϕ⧇ āϗ⧇āϛ⧇, āϤāĻžāχ compiler āĻĒāĻĄāĻŧ⧇āϛ⧇ 3.14159; * 2.0āĨ¤ Macro āĻŽāĻžāύ⧇ āϞ⧇āĻ–āĻž, āφāϰ āϞ⧇āĻ–āĻžāϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻ…āĻ•ā§āώāϰāχ āĻĸā§‹āϕ⧇āĨ¤

ā§Š. Macro-āϰ parameter-āϰ āϚāĻžāϰāĻĒāĻžāĻļ⧇ āĻŦāĻ¨ā§āϧāύ⧀ āύāĻž āĻĻ⧇āĻ“āϝāĻŧāĻžāĨ¤

#define SQUARE(x) x * x

printf("%d\n", SQUARE(2 + 3));

āĻ•āĻŋāϛ⧁āχ āĻŦāϞ⧇ āύāĻž, āφāϰ āĻ›āĻžāĻĒ⧇ 11āĨ¤ āϞ⧇āĻ–āĻžāϰ āĻŦāĻĻāϞāĻŋāϤ⧇ āĻĻāĻžāρāĻĄāĻŧāĻžāϝāĻŧ 2 + 3 * 2 + 3, āφāϰ āϗ⧁āĻŖ āφāϗ⧇ āĻšāϝāĻŧāĨ¤ āĻĒ⧁āϰ⧋ āĻļāϰ⧀āϰ āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž parameter āĻŽā§āĻĄāĻŧ⧇ āĻĻāĻžāĻ“: #define SQUARE(x) ((x) * (x))āĨ¤ āĻāĻ•āϟāĻž const-āϰ āĻāχ āϏāĻŽāĻ¸ā§āϝāĻžāϟāĻž āĻšāĻ“āϝāĻŧāĻžāχ āϏāĻŽā§āĻ­āĻŦ āύāĻž, āφāϰ āĻāϟāĻžāχ āĻ“āϟāĻžāϕ⧇ āφāϗ⧇ āϧāϰāĻžāϰ āφāϰ⧇āĻ•āϟāĻž āĻ•āĻžāϰāĻŖāĨ¤

ā§Ē. #define-āϰ āύāĻžāĻŽāϟāĻžāχ āφāĻŦāĻžāϰ variable āĻšāĻŋāϏ⧇āĻŦ⧇ āϞ⧇āĻ–āĻžāĨ¤

#define MAX_STUDENTS 60

int main(void)
{
    int MAX_STUDENTS = 30;
    return 0;
}

GCC 12 āĻŦāϞ⧇ error: expected identifier or '(' before numeric constant, āϏāĻžāĻĨ⧇ āϝ⧋āĻ— āĻ•āϰ⧇ note: in expansion of macro 'MAX_STUDENTS'āĨ¤ āĻ“ āĻĒāĻĄāĻŧ⧇āϛ⧇ int 60 = 30;āĨ¤ Macro-āϰ āϕ⧋āύ⧋ scope āύ⧇āχ, āϤāĻžāχ āĻ“āϟāĻž āϤ⧋āĻŽāĻžāϰ function-āϰ āĻ­āĻŋāϤāϰ⧇ āĻĸ⧁āϕ⧇ āύāĻžāĻŽāϟāĻž āϏ⧇āĻ–āĻžāύ⧇āĻ“ āĻŦāĻĻāϞ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāχ āĻ•āĻžāϰāϪ⧇āχ macro-āϰ āύāĻžāĻŽ āϚāĻŋāϰāĻ•āĻžāϞ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇ āĻšā§‡āρāϚāĻŋāϝāĻŧ⧇ āϞ⧇āĻ–āĻž āĻšāϝāĻŧāĨ¤

āĻŽāĻžāĻĨāĻžāϰ āĻ–ā§‹āϰāĻžāĻ•

Bob āĻāĻ•āϟāĻž timetable-āϰ āϜāĻ¨ā§āϝ lesson-āϰ āϏāĻŽāϝāĻŧāĻ•āĻžāϞ āϞāĻŋāĻ–āϛ⧇, āĻĻ⧁āχ āĻ…āĻ™ā§āϕ⧇ āϏāĻžāϜāĻŋāϝāĻŧ⧇, āϝāĻžāϤ⧇ āϤāĻžāϞāĻŋāĻ•āĻžāϟāĻž āĻ—ā§‹āĻ›āĻžāύ⧋ āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    int five = 05;
    int six = 06;
    int seven = 07;

    printf("%d %d %d\n", five, six, seven);
    return 0;
}

āĻāϟāĻž build āĻšāϝāĻŧ āφāϰ āĻ›āĻžāĻĒ⧇ 5 6 7, āϤāĻžāχ Bob āϝ⧋āĻ— āĻ•āϰ⧇ int eight = 08; āφāϰ program āφāϰ build āĻšāϝāĻŧ āύāĻžāĨ¤ āĻŦāϞ⧋ āϤ⧋ compiler āĻ“āϕ⧇ āϕ⧀ āĻŦāϞāϞ, āφāϰ āωāĻĒāϰ⧇āϰ āϤāĻŋāύ āϞāĻžāχāύ āϕ⧇āύ āĻ āĻŋāĻ• āĻ›āĻŋāϞāĨ¤

āϤāĻžāϰāĻĒāϰ āĻ•āĻ āĻŋāύ āĻ…āĻ°ā§āϧ⧇āĻ•āϟāĻžāĨ¤ āĻ“ āϏāĻžāϜāĻžāύ⧋ āϛ⧇āĻĄāĻŧ⧇ āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϰ⧁āϰ āϏāĻŦ āĻļā§‚āĻ¨ā§āϝ āĻŽā§āϛ⧇ āĻĻ⧇āϝāĻŧ, āϤāĻžāχ 05 āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ 5, āĻāĻ­āĻžāĻŦ⧇ 12 āĻĒāĻ°ā§āϝāĻ¨ā§āϤāĨ¤ āĻŦāĻžāϰ⧋āϟāĻž āĻ›āĻžāĻĒāĻž āĻŽāĻžāύ⧇āϰ āϕ⧋āύāϗ⧁āϞ⧋ āĻŦāĻĻāϞāĻžāϝāĻŧ, āφāϰ āϕ⧋āύāϗ⧁āϞ⧋ āĻŦāĻĻāϞāĻžāϝāĻŧ āύāĻž?

āĻļ⧁āϰ⧁āϰ āĻļā§‚āĻ¨ā§āϝ āϏāĻžāϜāϏāĻœā§āϜāĻž āύāĻž, āĻ“āϟāĻž āĻāĻ•āϟāĻž baseāĨ¤ āϤāĻžāϰāĻĒāϰ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧋, āĻ“āχ base-āĻ āϕ⧋āύ āϕ⧋āύ āĻ…āĻ™ā§āĻ• āĻĨāĻžāĻ•āĻžāϰ āĻ…āύ⧁āĻŽāϤāĻŋ āφāϛ⧇āĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§: named-receiptMedium

Maria-āϰ till, āφāĻŦāĻžāϰ āϞ⧇āĻ–āĻž, āϝāĻžāϤ⧇ VAT-āϰ āĻšāĻžāϰāϟāĻž āĻ āĻŋāĻ• āĻāĻ• āϞāĻžāχāύ⧇ āĻĨāĻžāϕ⧇āĨ¤ āĻāĻ•āϟāĻž āĻĒāϰāĻŋāĻŽāĻžāĻŖ āφāϰ āĻĒāϝāĻŧāϏāĻžāϝāĻŧ āĻĒā§āϰāϤāĻŋ āĻāĻ•āϕ⧇āϰ āĻĻāĻžāĻŽ āĻĒāĻĄāĻŧā§‹, āϤāĻžāϰāĻĒāϰ subtotal, VAT āφāϰ total āĻ›āĻžāĻĒā§‹āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻĻ⧁āχāϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž: āĻĒāϰāĻŋāĻŽāĻžāĻŖ, āϤāĻžāϰāĻĒāϰ āĻĒāϝāĻŧāϏāĻžāϝāĻŧ āĻĒā§āϰāϤāĻŋ āĻāĻ•āϕ⧇āϰ āĻĻāĻžāĻŽāĨ¤

Output. āϤāĻŋāύ āϞāĻžāχāύ, āĻĒā§āϰāϤāĻŋāϟāĻžāϝāĻŧ āĻāĻ•āϟāĻž āĻļāĻŦā§āĻĻ āϤāĻžāϰāĻĒāϰ āĻ…āĻ™ā§āĻ•āϟāĻž āĻĒā§‚āĻ°ā§āĻŖ āϟāĻžāĻ•āĻž, āĻāĻ•āϟāĻž āĻĻāĻžāρāĻĄāĻŧāĻŋ-āϚāĻŋāĻšā§āύ āφāϰ āĻĻ⧁āχ āĻ…āĻ™ā§āϕ⧇āϰ āĻĒāϝāĻŧāϏāĻž āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤

Constraints. 1 <= āĻĒāϰāĻŋāĻŽāĻžāĻŖ <= 100000, 1 <= āĻĒā§āϰāϤāĻŋ āĻāĻ•āϕ⧇āϰ āĻĻāĻžāĻŽ <= 10000000, VAT 15 āĻļāϤāĻžāĻ‚āĻļ āφāϰ āĻĒāϝāĻŧāϏāĻžāϰ āĻ­āĻ—ā§āύāĻžāĻ‚āĻļ āĻŦāĻžāĻĻāĨ¤ āϕ⧋āύ⧋ double āύāĻžāĨ¤

Sample. Input 3 12000 āĻĻāĻŋāϞ⧇ Subtotal 360.00, VAT 54.00, Total 414.00āĨ¤

#include <stdio.h>

int main(void)
{
    const long long VAT_PERCENT = 15;
    const long long PAISA_PER_TAKA = 100;
    const long long PERCENT_WHOLE = 100;

    long long quantity = 0;
    long long unit_paisa = 0;
    scanf("%lld %lld", &quantity, &unit_paisa);

    /* Three lines. %02lld is what makes five paisa print as 05. */

    return 0;
}

named-receipt āύāĻžāĻŽā§‡ gradedāĨ¤ āĻāĻ•āĻļā§‹ āĻĻ⧁āχāϟāĻžāϰ āĻŽāĻžāύ⧇ āĻĻ⧁āχ āϰāĻ•āĻŽ, āϤāĻžāχ āĻ“āϰāĻž āĻĻ⧁āχāϟāĻž constant, āĻāĻ•āϟāĻž āύāĻžāĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ⧍: base-decoderEasy

Amara-āϰ config file permission āϞ⧇āϖ⧇ base 8-āĻ āφāϰ āϰāĻ™ āϞ⧇āϖ⧇ base 16-āĻāĨ¤ āĻĻ⧁āχāϟāĻžāχ decimal-āĻ āĻ›āĻžāĻĒā§‹āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž hexadecimal āϏāĻ‚āĻ–ā§āϝāĻž āϤāĻžāϰāĻĒāϰ āĻāĻ•āϟāĻž octal āϏāĻ‚āĻ–ā§āϝāĻž, āϕ⧋āύ⧋ prefix āĻ›āĻžāĻĄāĻŧāĻžāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āĻĻ⧁āχāϟāĻžāχ decimal-āĻ, āĻŽāĻžāĻā§‡ āĻāĻ•āϟāĻž āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻžāĨ¤

Constraints. Hex 0 āĻĨ⧇āϕ⧇ FFFFFF, āϝ⧇āϕ⧋āύ⧋ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇; octal 0 āĻĨ⧇āϕ⧇ 7777777āĨ¤

Sample. Input 1F 755 āĻĻāĻŋāϞ⧇ 31 493āĨ¤

#include <stdio.h>

int main(void)
{
    unsigned int from_hex = 0;
    unsigned int from_octal = 0;
    scanf("%x %o", &from_hex, &from_octal);

    /* One printf. Both boxes already hold ordinary numbers. */

    return 0;
}

base-decoder āύāĻžāĻŽā§‡ gradedāĨ¤ āĻāχ module-āϰ lesson 4 scanf āϞāĻžāχāύāϟāĻž āĻŦā§‹āĻāĻžāϝāĻŧ; āĻāĻ–āĻžāύ⧇ āϏ⧇āϟāĻž āϞāĻŋāϖ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āφāϛ⧇āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§Š: āĻŦ⧃āĻ¤ā§āϤāϟāĻž, āĻĻ⧁āχāĻŦāĻžāϰHard

Zara āĻ—ā§‹āϞ mat āĻ•āĻžāϟāϛ⧇ āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰāĻĢāϞ āφāϰ āĻ•āĻŋāύāĻžāϰāĻžāϰ āĻĻ⧈āĻ°ā§āĻ˜ā§āϝ āϚāĻžāϝāĻŧ, āĻāĻ•āϟāĻž āĻŦā§āϝāĻžāϏāĻžāĻ°ā§āϧ āφāϰ āύāĻžāĻŽ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻāĻ•āϟāĻž pi āĻĨ⧇āϕ⧇āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž āĻĻāĻļāĻŽāĻŋāĻ• āϏāĻ‚āĻ–ā§āϝāĻž, āĻŦā§āϝāĻžāϏāĻžāĻ°ā§āϧāĨ¤

Output. āĻĻ⧁āχ āϞāĻžāχāύ: āĻ•ā§āώ⧇āĻ¤ā§āϰāĻĢāϞ, āϤāĻžāϰāĻĒāϰ āĻĒāϰāĻŋāϧāĻŋ, āĻĻ⧁āχāϟāĻžāχ āĻ āĻŋāĻ• āĻĻ⧁āχ āĻĻāĻļāĻŽāĻŋāĻ• āϘāϰ āĻĒāĻ°ā§āϝāĻ¨ā§āϤāĨ¤

Constraints. const double PI = 3.14159265358979; āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧋ āφāϰ āĻ…āĻ™ā§āĻ•āϗ⧁āϞ⧋ āĻāĻ•āĻŦāĻžāϰāχ āϞ⧇āĻ–ā§‹āĨ¤

Sample. Input 2.5 āĻĻāĻŋāϞ⧇ 19.63 āϤāĻžāϰāĻĒāϰ 15.71āĨ¤

#include <stdio.h>

int main(void)
{
    const double PI = 3.14159265358979;

    double radius = 0.0;
    scanf("%lf", &radius);

    /* Two printf calls, both using PI, neither repeating its digits. */

    return 0;
}

āĻāχ module-āĻ graded āύāĻžāĨ¤ āϤāĻžāϰāĻĒāϰ #define PI 3.14159265358979 āĻĻāĻŋāϝāĻŧ⧇ āφāϰ⧇āĻ•āĻŦāĻžāϰ āĻ•āϰ⧋ āφāϰ āĻĻ⧇āϖ⧇ āύāĻžāĻ“ output āĻšā§āĻŦāĻšā§ āĻāĻ•āĨ¤ āĻĻ⧁āχāϟāĻžāϰ āϤāĻĢāĻžāϤ āĻŽāĻžāύ⧁āώ āύāĻŋāϝāĻŧ⧇, āĻ…āĻ™ā§āĻ• āύāĻŋāϝāĻŧ⧇ āύāĻžāĨ¤

Run in Compiler

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

  • Constant-āϰ āύāĻžāĻŽ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ āϕ⧇āύ?

    āĻ…āĻ­ā§āϝāĻžāϏ, āφāϰ āĻ•āĻžāĻœā§‡āϰ āĻ…āĻ­ā§āϝāĻžāϏāĨ¤ āĻļ⧁āϰ⧁āϟāĻž macro āĻĻāĻŋāϝāĻŧ⧇, āϝ⧇āĻ–āĻžāύ⧇ āύāĻžāĻŽ āϭ⧁āϞ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻĒ⧌āρāϛ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ āĻŦāĻŋāĻĒāĻĻāĨ¤ āϤāĻžāϰāĻĒāϰ const-āϤ⧇āĻ“ āĻ›āĻĄāĻŧāĻŋāϝāĻŧ⧇āϛ⧇, āĻ•āĻžāϰāĻŖ āĻĒāĻžāĻ āĻ• āϤāĻ–āύ āĻāĻ• āύāϜāϰ⧇āχ āĻŦā§‹āĻā§‡ āĻŽāĻžāύāϟāĻž āĻ•āĻ–āύ⧋ āύāĻĄāĻŧ⧇ āύāĻžāĨ¤

  • #define-āϰ āĻšā§‡āϝāĻŧ⧇ const āĻ•āĻŋ āĻŦ⧇āĻļāĻŋ memory āĻ–āĻžāϝāĻŧ?

    āĻ•āĻžāĻ—āĻœā§‡-āĻ•āϞāĻŽā§‡ āĻšā§āϝāĻžāρ, āĻŦāĻžāĻ¸ā§āϤāĻŦ⧇ āĻĒā§āϰāĻžāϝāĻŧ āĻ•āĻ–āύ⧋āχ āύāĻžāĨ¤ āϝ⧇āϕ⧋āύ⧋ optimisation āĻ¸ā§āϤāϰ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž compiler āϛ⧋āϟ āĻāĻ•āϟāĻž const-āϕ⧇ āϏ⧋āϜāĻž āĻ“āχ instruction-āϰ āĻ­āĻŋāϤāϰ⧇āχ āĻŦāϏāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ, āĻ āĻŋāĻ• āϝ⧇āĻŽāύ macro āĻ•āϰāϤāĨ¤

  • 3.14f āĻ•āĻŋ 3.14-āϰ āĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽ āύāĻŋāϖ⧁āρāϤ?

    āĻšā§āϝāĻžāρāĨ¤ f suffix āĻ“āϟāĻžāϕ⧇ float āĻŦāĻžāύāĻžāϝāĻŧ, āϝ⧇āϟāĻž āĻĒā§āϰāĻžāϝāĻŧ 7 āĻ…āĻ™ā§āĻ• āĻŦāϝāĻŧ, āφāϰ double āĻŦāϝāĻŧ 15āĨ¤ Module 2-āϰ lesson 3 āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇āĻ›āĻŋāϞ āĻāϤ⧇ āϕ⧀ āĻšāĻžāϰāĻžāϝāĻŧ, āφāϰ āϏ⧇āĻ–āĻžāύāĻ•āĻžāϰ āωāĻ¤ā§āϤāϰ āĻ›āĻŋāϞ āĻ•āĻžāϰāĻŖ āύāĻž āĻĨāĻžāĻ•āϞ⧇ double āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧋āĨ¤

  • āϝ⧇āϟāĻž āĻĒāϰ⧇ āĻŦāĻĻāϞāĻžāĻŦ, āϤāĻžāϤ⧇āĻ“ āĻ•āĻŋ const āϞ⧇āĻ–āĻž āϝāĻžāϝāĻŧ?

    āύāĻž, āφāϰ āĻ“āϟāĻžāχ āϤ⧋ āĻāϰ āĻŽāĻžāύ⧇āĨ¤ Compiler assign āĻ•āϰāĻžāϟāĻžāχ āĻŽāĻžāύāĻž āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ, āφāϰ āϏ⧇āϟāĻžāχ āĻĒāϰ⧇āϰ lessonāĨ¤

  • āĻŽāĻžāύāϕ⧇ āύāĻžāĻŽ āĻĻ⧇āĻ“āϝāĻŧāĻžāϰ āĻ•āĻŋ #define āφāϰ const-āχ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āĻĒāĻĨ?

    āύāĻžāĨ¤ enum āϤ⧃āϤ⧀āϝāĻŧ āĻĒāĻĨ, āφāϰ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻāĻ•āϟāĻž āϏ⧇āĻŸā§‡āϰ āϜāĻ¨ā§āϝ āϤāĻŋāύāϟāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āĻ“āϟāĻžāχ āϏ⧇āϰāĻžāĨ¤ Module 12 āĻ“āϟāĻžāϕ⧇ āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž lesson āĻĻ⧇āϝāĻŧāĨ¤

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

  • āĻĒā§āϰāϤāĻŋāϟāĻž āĻ–āĻžāϞāĻŋ āĻŽāĻžāύ āĻāĻ•āϟāĻž literal, āφāϰ āϕ⧀āĻ­āĻžāĻŦ⧇ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ⧇āϛ⧇ āϤāĻž-āχ āϤāĻžāϰ type āĻ āĻŋāĻ• āĻ•āϰ⧇āĨ¤
  • Suffix āĻĻāĻŋāϝāĻŧ⧇ āϤ⧁āĻŽāĻŋ āĻŦāϞ⧋ āϝ⧇ int āĻŦāĻž double āĻ›āĻžāĻĄāĻŧāĻž āĻ…āĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ āĻšā§‡āϝāĻŧ⧇āĻ›āĻŋāϞ⧇āĨ¤
  • āĻļ⧁āϰ⧁āϤ⧇ āĻļā§‚āĻ¨ā§āϝ āĻŽāĻžāύ⧇ base 8, āϚ⧁āĻĒāϚāĻžāĻĒ, āφāϰ 010 āĻšāϞ⧋ 8āĨ¤
  • #define āĻšāϞ⧋ compiler-āϰ āφāϗ⧇ āĻšāĻ“āϝāĻŧāĻž āĻāĻ•āϟāĻž āϞ⧇āĻ–āĻžāϰ āĻŦāĻĻāϞ, type āύ⧇āχ āφāϰ scope āύ⧇āχāĨ¤
  • const āĻšāϞ⧋ type āφāϰ scope āϏāĻš āĻāĻ•āϟāĻž variable, āϝāĻžāϤ⧇ compiler assign āĻ•āϰāϤ⧇ āĻĻ⧇āϝāĻŧ āύāĻž; āφāϗ⧇ āĻāϟāĻžāχ āϧāϰ⧋āĨ¤
  • Magic number āĻŽāĻžāύ⧇ āϝ⧇ āĻŽāĻžāύ⧇āϰ āĻ…āĻ°ā§āĻĨ āϕ⧇āω āφāϰ āωāĻĻā§āϧāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž, āφāϰ āύāĻžāĻŽ āĻĻāĻŋāϞ⧇ āϚāϞāĻžāϰ āϏāĻŽāϝāĻŧ āϕ⧋āύ⧋ āĻ–āϰāϚ āĻŦāĻžāĻĄāĻŧ⧇ āύāĻžāĨ¤

āĻāϰāĻĒāϰ āĻĻ⧇āĻ–āĻŦ⧇ const āϞāĻŋāϖ⧇ āĻĢ⧇āϞāĻžāϰ āĻĒāϰ compiler āφāϏāϞ⧇ āϕ⧀ āϕ⧀ āĻŽāĻžāύāĻž āĻ•āϰ⧇, āφāϰ āϏ⧇āχ āĻāĻ•āϟāĻž qualifier-āϰ āĻĻ⧇āĻ–āĻž āĻĒāĻžāĻŦ⧇ āϝ⧇āϟāĻž āĻ“āϕ⧇ āϚāĻžāϞāĻžāĻ•āĻŋ āĻŦāĻ¨ā§āϧ āĻ•āϰāϤ⧇ āĻŦāϞ⧇āĨ¤

lesson ā§§ āĻļ⧇āώ

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

āĻĒāϰ⧇āϰāϟāĻž: Const āφāϰ volatile: compiler-āϕ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ