Learn C Programming

lesson ā§Ē / ā§Ž ¡ C-āϰ āϏāĻ™ā§āϗ⧇ āĻĒāϰāĻŋāϚāϝāĻŧ: āĻĒā§āϰāĻĨāĻŽ program, āϚāĻŋāĻšā§āύ āϧāϰ⧇ āϧāϰ⧇

Module ā§§ ¡ C-āϰ āϏāĻ™ā§āϗ⧇ āĻĒāϰāĻŋāϚāϝāĻŧ: āĻĒā§āϰāĻĨāĻŽ program, āϚāĻŋāĻšā§āύ āϧāϰ⧇ āϧāϰ⧇

āĻĒ⧁āϰ⧋ ASCII āĻŸā§‡āĻŦāĻŋāϞ, ā§§ā§¨ā§ŽāϟāĻž āϏāĻžāϰāĻŋāχ

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

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

  • C-āϤ⧇ āĻāĻ•āϟāĻž char āφāϏāϞ⧇ āϕ⧇āύ āϛ⧋āϟ āĻāĻ•āϟāĻž integer, āϏ⧇āϟāĻž āĻŦā§‹āĻāĻžāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤
  • āϚāĻžāϰāϟāĻž āύ⧋āĻ™āϰ āĻŽāύ⧇ āϰāĻžāĻ–āĻŦ⧇: '0' āĻŽāĻžāύ⧇ 48, 'A' āĻŽāĻžāύ⧇ 65, 'a' āĻŽāĻžāύ⧇ 97, āφāϰ āĻāĻ•āϟāĻž space āĻŽāĻžāύ⧇ 32āĨ¤
  • āϤāĻŋāύāϟāĻž āĻšāĻŋāϏāĻžāĻŦ⧇āϰ āĻ•ā§ŒāĻļāϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āύāĻŋāĻšā§‡āϰ āĻĒ⧁āϰ⧋ table-āϰ āϝ⧇āϕ⧋āύ⧋ āϏāĻžāϰāĻŋ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

Computer āϏāĻ‚āĻ–ā§āϝāĻž āϜāĻŽāĻž āϰāĻžāϖ⧇āĨ¤ āϕ⧇āĻŦāϞ āϏāĻ‚āĻ–ā§āϝāĻžāĨ¤ āϤāĻžāĻšāϞ⧇ āϏ⧇ A āĻ…āĻ•ā§āώāϰāϟāĻž āϜāĻŽāĻž āϰāĻžāϖ⧇ āϕ⧀ āĻ•āϰ⧇?

āϏ⧇ āĻāĻ•āϟāĻž code-āĻ āϰāĻžāϜāĻŋ āĻšāϝāĻŧāĨ¤ 1963 āϏāĻžāϞ⧇ āĻāĻ•āϟāĻž standard āĻāχ āϰāĻžāϜāĻŋ āĻšāĻ“āϝāĻŧāĻžāϟāĻž āϞāĻŋāϖ⧇ āϰāĻžāϖ⧇: A āĻŽāĻžāύ⧇ 65, B āĻŽāĻžāύ⧇ 66, āĻāĻ­āĻžāĻŦ⧇ 127 āĻĒāĻ°ā§āϝāĻ¨ā§āϤāĨ¤ āĻ“āϟāĻžāϰ āύāĻžāĻŽ American Standard Code for Information Interchange, āϏāĻ‚āĻ•ā§āώ⧇āĻĒ⧇ ASCIIāĨ¤ āϝ⧇ āĻŽā§‡āĻļāĻŋāύ āĻāϟāĻž āĻŽāĻžāύ⧇, āϏ⧇ āĻāĻ•āχ byte āĻāĻ•āχ āĻ­āĻžāĻŦ⧇ āĻĒāĻĄāĻŧ⧇āĨ¤

āĻāχ lesson āĻāĻ•āϟāĻž reference page, āϝāĻžāϰ āϭ⧇āϤāϰ⧇ āĻĒ⧁āϰ⧋ āϰāĻžāϜāĻŋāύāĻžāĻŽāĻžāϟāĻž āĻ›āĻžāĻĒāĻž āφāϛ⧇, āϏāĻ™ā§āϗ⧇ āĻ“āϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻĒāĻžāρāϚāϟāĻž āϛ⧋āϟ programāĨ¤

āĻāĻ• byte, āĻĻ⧁āχ āϰāĻ•āĻŽ āĻĒāĻĄāĻŧāĻž

C-āϤ⧇ āĻāĻ•āϟāĻž char āφāϏāϞ⧇ āĻ…āĻ•ā§āώāϰ āύāĻžāĨ¤ āĻāϟāĻž āϛ⧋āϟ āĻāĻ•āϟāĻž integer, āϝāĻžāϕ⧇ āĻĒāĻ°ā§āĻĻāĻžāϝāĻŧ āĻ…āĻ•ā§āώāϰ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĻ⧇āĻ–āĻžāϤ⧇ āϤ⧁āĻŽāĻŋ āϰāĻžāϜāĻŋ āĻšāϝāĻŧ⧇āĻ›āĨ¤

āϏ⧇āϜāĻ¨ā§āϝāχ āĻāĻ•āχ variable āĻĻ⧁āχ āϰāĻ•āĻŽā§‡ āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧāĨ¤ %c āĻŦāϞ⧇ "āĻāχ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āϝ⧇ character āĻŦā§‹āĻāĻžāϝāĻŧ, āĻ“āϟāĻž āĻĻ⧇āĻ–āĻžāĻ“"āĨ¤ %d āĻŦāϞ⧇ "āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻžāχ āĻĻ⧇āĻ–āĻžāĻ“"āĨ¤

#include <stdio.h>

int main(void)
{
    char letter = 'A';

    printf("As a character: %c\n", letter);
    printf("As a number:    %d\n", letter);
    return 0;
}
As a character: A
As a number:    65

āĻ“āχ āĻĻ⧁āχ āϞāĻžāχāύ⧇āϰ āĻŽāĻžāĻā§‡ āĻ•āĻŋāϛ⧁āχ āĻŦāĻĻāϞ⧇ āύ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāύāĻŋāĨ¤ Memory-āϰ byte-āϟāĻž āĻāĻ•āĻŦāĻžāϰāĻ“ āĻŦāĻĻāϞāĻžāϝāĻŧāύāĻŋāĨ¤ āĻļ⧁āϧ⧁ āϤ⧁āĻŽāĻŋ āϕ⧋āύ āĻ•āĻžāϚ āĻĻāĻŋāϝāĻŧ⧇ āĻ“āϟāĻžāϰ āĻĻāĻŋāϕ⧇ āϤāĻžāĻ•āĻŋāϝāĻŧ⧇āĻ›, āϏ⧇āϟāĻž āĻŦāĻĻāϞ⧇āϛ⧇āĨ¤

āϚāĻžāϰāϟāĻž āύ⧋āĻ™āϰ āφāϰ āϤāĻŋāύāϟāĻž āĻ•ā§ŒāĻļāϞ

āϤ⧋āĻŽāĻžāϕ⧇ 128āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āĻļāĻŋāĻ–āϤ⧇ āĻšāĻŦ⧇ āύāĻžāĨ¤ āϚāĻžāϰāϟāĻž āϞāĻžāĻ—āĻŦ⧇, āφāϰ āĻŦāĻžāĻ•āĻŋ āϏāĻŦ āĻšāĻŋāϏāĻžāĻŦ āĻ•āϰ⧇ āĻŦ⧇āϰāĻŋāϝāĻŧ⧇ āφāϏ⧇āĨ¤

CharacterCodeāĻĒ⧁āϰ⧋ āĻĻāϞāϟāĻž
'0'48āĻ…āĻ™ā§āĻ• '0' āĻĨ⧇āϕ⧇ '9' āĻŽāĻžāύ⧇ 48 āĻĨ⧇āϕ⧇ 57
'A'65āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ 'A' āĻĨ⧇āϕ⧇ 'Z' āĻŽāĻžāύ⧇ 65 āĻĨ⧇āϕ⧇ 90
'a'97āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ 'a' āĻĨ⧇āϕ⧇ 'z' āĻŽāĻžāύ⧇ 97 āĻĨ⧇āϕ⧇ 122
āĻāĻ•āϟāĻž space32āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ āĻāĻŽāύ āϏāĻŦāĻžāϰ āĻĒā§āϰāĻĨāĻŽ character

āĻāχ āϚāĻžāϰāϟāĻž āĻĨ⧇āϕ⧇ āϤāĻŋāύāϟāĻž āĻ•ā§ŒāĻļāϞ āĻŦ⧇āϰ⧋āϝāĻŧ, āφāϰ character āύāĻŋāϝāĻŧ⧇ āϤ⧋āĻŽāĻžāϰ āφāϏāϞ āĻ•āĻžāĻœā§‡āϰ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ—āχ āĻ“āϤ⧇ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤

  1. 32 āĻĻāĻŋāϝāĻŧ⧇ case āĻŦāĻĻāϞāĻžāĻ“āĨ¤ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ āϤāĻžāϰ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰāϟāĻžāϰ āĻ āĻŋāĻ• 32 āωāĻĒāϰ⧇, āϤāĻžāχ 'a' - 'A' āĻŽāĻžāύ⧇ 32āĨ¤
  2. āĻ…āĻ™ā§āϕ⧇āϰ character āĻĨ⧇āϕ⧇ āĻ…āĻ™ā§āϕ⧇āϰ āĻŽāĻžāύ: '0' āĻŦāĻŋāϝāĻŧā§‹āĻ— āĻ•āϰ⧋āĨ¤ '7' - '0' āĻŽāĻžāύ⧇ 7, āĻ•āĻžāϰāĻŖ 55 āĻĨ⧇āϕ⧇ 48 āĻŦāĻžāĻĻ āĻĻāĻŋāϞ⧇ 7āĨ¤
  3. āĻ…āĻ•ā§āώāϰ āĻĨ⧇āϕ⧇ āĻŦāĻ°ā§āĻŖāĻŽāĻžāϞāĻžāϰ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāύ: 'A' āĻŦāĻž 'a' āĻŦāĻŋāϝāĻŧā§‹āĻ— āĻ•āϰ⧋āĨ¤ 'D' - 'A' āĻŽāĻžāύ⧇ 3, āϤāĻžāχ D āϚāϤ⧁āĻ°ā§āĻĨ āĻ…āĻ•ā§āώāϰāĨ¤

āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋, āϤāĻŋāύāϟāĻžāϤ⧇āχ āĻāĻ•āϟāĻž āϜāĻŋāύāĻŋāϏ āĻŽāĻŋāϞ āφāϛ⧇āĨ¤ āϤ⧁āĻŽāĻŋ āύāĻŋāĻœā§‡āϰ code-āĻ āĻ•āĻ–āύ⧋ 48, 65 āĻŦāĻž 97 āϞāĻŋāĻ–āĻ› āύāĻžāĨ¤ āϤ⧁āĻŽāĻŋ āϞāĻŋāĻ–āĻ› '0', 'A' āĻŦāĻž 'a', āφāϰ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž compiler āĻŦāϏāĻŋāϝāĻŧ⧇ āĻĻāĻŋāĻšā§āϛ⧇, āϝāĻžāϤ⧇ āϞāĻžāχāύāϟāĻž āĻĒāĻĄāĻŧāĻž āϝāĻžāϝāĻŧāĨ¤

āϤāĻžāχ āĻŦāĻŋāϝāĻŧā§‹āĻ— āĻ•āϰāϤ⧇ āĻĒāĻžāϰāϞ⧇āχ āϤ⧁āĻŽāĻŋ āĻāĻ•āϟāĻžāĻ“ library function āĻ›āĻžāĻĄāĻŧāĻž case āĻŦāĻĻāϞ, āĻ…āĻ™ā§āĻ• āĻĒāĻĄāĻŧāĻž āφāϰ āĻŦāĻ°ā§āĻŖāĻŽāĻžāϞāĻžāϰ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāύ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧋āĨ¤

Control character: 0 āĻĨ⧇āϕ⧇ 31, āφāϰ 127

āĻĒā§āϰāĻĨāĻŽ 32āϟāĻž code āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ āύāĻžāĨ¤ āĻ“āϰāĻž control character: teleprinter-āϰ āφāĻŽāϞ⧇āϰ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ, āĻŽāĻžāύ⧇ āϝ⧇ āĻŽā§‡āĻļāĻŋāύ āϤāĻžāϰ āĻĻāĻŋāϝāĻŧ⧇ āϞ⧇āĻ–āĻž āĻĒāĻžāĻ āĻžāϤāĨ¤ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ—āχ āĻāĻ–āύ āϜāĻžāĻĻ⧁āϘāϰ⧇āϰ āϜāĻŋāύāĻŋāϏāĨ¤ āĻĒāĻžāρāϚāϟāĻžāϰ āĻāĻ–āύ⧋ āĻĻāϰāĻ•āĻžāϰ āφāϛ⧇, āφāϰ āĻ“āϗ⧁āϞ⧋ āĻŽā§‹āϟāĻž āĻšāϰāĻĢ⧇āĨ¤

DecHexāύāĻžāĻŽāĻĒ⧁āϰ⧋ āύāĻžāĻŽāϝāĻž āĻ•āϰ⧇
000NULNullāĻāĻ•āϟāĻž C string āĻļ⧇āώ āĻ•āϰ⧇, Module 10-āĻ āϝ⧇āϟāĻžāϰ āϏāĻ™ā§āϗ⧇ āĻĻ⧇āĻ–āĻž āĻšāĻŦ⧇
101SOHStart of headingTeleprinter-āϰ heading āϚāĻŋāĻšā§āύ, āφāϜ āĻ…āĻŦā§āϝāĻŦāĻšā§ƒāϤ
202STXStart of textāĻŦāĻžāĻ°ā§āϤāĻž āϕ⧋āĻĨāĻžāϝāĻŧ āĻļ⧁āϰ⧁, āϏ⧇āϟāĻž āϚāĻŋāĻšā§āύāĻŋāϤ āĻ•āϰāϤ
303ETXEnd of textTerminal-āĻ Ctrl āφāϰ C āĻāĻ•āϏāĻ™ā§āϗ⧇ āϚāĻžāĻĒāϞ⧇ āĻāϟāĻžāχ āϝāĻžāϝāĻŧ
404EOTEnd of transmissionCtrl āφāϰ D āϚāĻžāĻĒāϞ⧇ āĻāϟāĻž āϝāĻžāϝāĻŧ, input-āϰ āĻļ⧇āώ āϧāϰāĻž āĻšāϝāĻŧ
505ENQEnquiryāĻ…āĻ¨ā§āϝ āĻŽā§‡āĻļāĻŋāύāϕ⧇ āωāĻ¤ā§āϤāϰ āĻĻāĻŋāϤ⧇ āĻŦāϞāϤ
606ACKAcknowledgeāĻ…āĻ¨ā§āϝ āĻŽā§‡āĻļāĻŋāύ⧇āϰ āĻšā§āϝāĻžāρ
707BELBellTerminal-āϰ āϘāĻŖā§āϟāĻž āĻŦāĻžāϜāĻžāϝāĻŧāĨ¤ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ \a
808BSBackspaceāĻāĻ• character āĻĒ⧇āĻ›āύ⧇ āϝāĻžāϝāĻŧāĨ¤ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ \b
909HTHorizontal tabāĻĒāϰ⧇āϰ tab-āϰ āϘāϰ⧇ āϞāĻžāĻĢ āĻĻ⧇āϝāĻŧāĨ¤ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ \t
100ALFLine feedLinux āφāϰ macOS-āϰ newlineāĨ¤ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ \n
110BVTVertical tabāĻ•āĻžāĻ—āĻœā§‡ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻāĻ•āϟāĻž āĻĻā§‚āϰāĻ¤ā§āĻŦ āύāĻŋāĻšā§‡ āύāĻžāĻŽāϤ
120CFFForm feedPrinter-āĻ āĻĒāĻžāϤāĻž āĻŦ⧇āϰ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ \f
130DCRCarriage returnāϞāĻžāχāύ⧇āϰ āĻļ⧁āϰ⧁āϤ⧇ āĻĢ⧇āϰ⧇āĨ¤ Windows āϞ⧇āϖ⧇ CR āϤāĻžāϰāĻĒāϰ LF
140ESOShift outāĻŦāĻŋāĻ•āĻ˛ā§āĻĒ āĻāĻ•āϟāĻž character set-āĻ āϚāϞ⧇ āϝ⧇āϤ
150FSIShift ināφāĻŦāĻžāϰ āφāϗ⧇āϰāϟāĻžāϝāĻŧ āĻĢāĻŋāϰ⧇ āφāϏāϤ
1610DLEData link escapeLink-āϕ⧇ āĻŦāϞāϤ, āĻāϰ āĻĒāϰ⧇āϰāϟāĻž āĻāĻ•āϟāĻž command
1711DC1Device control 1āĻāϕ⧇ XON-āĻ“ āĻŦāϞ⧇: āĻĒāĻžāĻ āĻžāύ⧋ āφāĻŦāĻžāϰ āĻļ⧁āϰ⧁ āĻ•āϰ⧋
1812DC2Device control 2Device-āϰ āĻāĻ•āϟāĻž āĻŦāĻžāĻĄāĻŧāϤāĻŋ āϏāĻ‚āϕ⧇āϤ
1913DC3Device control 3āĻāϕ⧇ XOFF-āĻ“ āĻŦāϞ⧇: āĻĒāĻžāĻ āĻžāύ⧋ āĻĨāĻžāĻŽāĻžāĻ“
2014DC4Device control 4Device-āϰ āĻāĻ•āϟāĻž āĻŦāĻžāĻĄāĻŧāϤāĻŋ āϏāĻ‚āϕ⧇āϤ
2115NAKNegative acknowledgeāĻ…āĻ¨ā§āϝ āĻŽā§‡āĻļāĻŋāύ⧇āϰ āύāĻž
2216SYNSynchronous idleāϏāĻŽāϝāĻŧ āϰāĻžāĻ–āϤ⧇ āϚ⧁āĻĒāϚāĻžāĻĒ line āĻ­āϰāĻŋāϝāĻŧ⧇ āϰāĻžāĻ–āϤ
2317ETBEnd of transmission blockāϞāĻŽā§āĻŦāĻž āĻŦāĻžāĻ°ā§āϤāĻžāϰ āĻāĻ•āϟāĻž block āĻļ⧇āώ āĻ•āϰāϤ
2418CANCancelāĻŦāϞāϤ, āĻāϰ āφāϗ⧇āϰ data āϭ⧁āϞ āĻ›āĻŋāϞ
2519EMEnd of mediumTape āĻŦāĻž card āĻļ⧇āώ āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇
261ASUBSubstituteWindows-āĻ Ctrl āφāϰ Z, file-āϰ āĻļ⧇āώ āϧāϰāĻž āĻšāϝāĻŧ
271BESCEscapeTerminal-āϰ āϰāϙ⧇āϰ code āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĨ¤ āϞ⧇āĻ–āĻž āĻšāϝāĻŧ \033
281CFSFile separatorāϚāĻžāϰāϟāĻž separator-āϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧāϟāĻž
291DGSGroup separatorFile-āϰ āϭ⧇āϤāϰ⧇ group āφāϞāĻžāĻĻāĻž āĻ•āϰāϤ
301ERSRecord separatorGroup-āϰ āϭ⧇āϤāϰ⧇ record āφāϞāĻžāĻĻāĻž āĻ•āϰāϤ
311FUSUnit separatorRecord-āϰ āϭ⧇āϤāϰ⧇ field āφāϞāĻžāĻĻāĻž āĻ•āϰāϤ
1277FDELDeleteāĻ•āĻžāĻ—āĻœā§‡āϰ tape-āĻ āϏāĻžāϤāϟāĻž āĻĢ⧁āĻŸā§‹āχ āĻ•āĻžāϟāĻž, āĻŽāĻžāύ⧇ āĻāϟāĻž āĻŦāĻžāĻĻ āĻĻāĻžāĻ“

āĻŽā§‹āϟāĻž āĻšāϰāĻĢ⧇āϰ āĻĒāĻžāρāϚāϟāĻžāχ āϤ⧁āĻŽāĻŋ āϏāĻ¤ā§āϝāĻŋāχ āϞāĻŋāĻ–āĻŦ⧇āĨ¤ NUL string āĻļ⧇āώ āĻ•āϰ⧇, HT āĻŽāĻžāύ⧇ \t āφāϰ LF āĻŽāĻžāύ⧇ \nāĨ¤ CR āĻšāϞ⧋ Windows-āϰ āϞāĻžāχāύ āĻļ⧇āώ⧇āϰ āĻ…āĻ¨ā§āϝ āĻ…āĻ°ā§āϧ⧇āĻ•, āφāϰ ESC terminal-āĻ āϰāĻ™ āĻŦāϏāĻžāύ⧋āϰ code āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĨ¤

āϤāĻžāχ āĻāĻ•āϟāĻžāĻ“ control character āύ⧇āχ āĻāĻŽāύ āĻāĻ•āϟāĻž text file āĻšāϤ⧋ āĻāĻ•āϟāĻžāχ āĻ…āĻļ⧇āώ āϞāĻžāχāύāĨ¤

āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ āĻāĻŽāύ āĻ…āĻ°ā§āϧ⧇āĻ•: 32 āĻĨ⧇āϕ⧇ 126, āĻĒ⧁āϰ⧋āϟāĻž

32 āĻĨ⧇āϕ⧇ 126 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āĻāĻ•āϟāĻž āĻĻ⧇āĻ–āĻžāϰ āĻŽāϤ⧋ āφāĻ•āĻžāϰ āφāϛ⧇āĨ¤ Table-āϟāĻž āĻŦāĻžāĻŽ āĻĨ⧇āϕ⧇ āĻĄāĻžāύ⧇ āϚāĻžāϰāϟāĻž āĻ–āĻŖā§āĻĄā§‡ āĻĒāĻĄāĻŧā§‹āĨ¤ āĻĒā§āϰāĻĨāĻŽ āĻ–āĻŖā§āĻĄā§‡āϰ āĻĒā§āϰāĻĨāĻŽ āϘāϰāϟāĻž space character, āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āĻ“āϟāĻž āĻĢāĻžāρāĻ•āĻž āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤

DecHexCharDecHexCharDecHexCharDecHexChar
3220space563888050P10468h
3321!573998151Q10569i
3422"583A:8252R1066Aj
3523#593B;8353S1076Bk
3624$603C<8454T1086Cl
3725%613D=8555U1096Dm
3826&623E>8656V1106En
3927'633F?8757W1116Fo
4028(6440@8858X11270p
4129)6541A8959Y11371q
422A*6642B905AZ11472r
432B+6743C915B[11573s
442C,6844D925C\11674t
452D-6945E935D]11775u
462E.7046F945E^11876v
472F/7147G955F_11977w
483007248H9660`12078x
493117349I9761a12179y
50322744AJ9862b1227Az
51333754BK9963c1237B{
52344764CL10064d1247C|
53355774DM10165e1257D}
54366784EN10266f1267E~
55377794FO10367g

Table-āϟāĻžāϰ āϭ⧇āϤāϰ⧇āχ āϤāĻŋāύāϟāĻž āύāĻ•āĻļāĻž āĻĻ⧇āĻ–āĻžāϰ āĻŽāϤ⧋āĨ¤ āĻ…āĻ™ā§āĻ•āϗ⧁āϞ⧋ āĻāĻ•āϏāĻ™ā§āϗ⧇, āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāϗ⧁āϞ⧋ āĻāĻ•āϏāĻ™ā§āϗ⧇, āφāϰ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰāϗ⧁āϞ⧋ āĻāĻ•āϏāĻ™ā§āϗ⧇ āĻŦāϏ⧇ āφāϛ⧇, āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻāϞ āĻ…āĻŦāĻŋāĻšā§āĻ›āĻŋāĻ¨ā§āύāĨ¤

65 āφāϰ 97-āϰ āĻĻāĻŋāϕ⧇ āϤāĻžāĻ•āĻžāĻ“āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϏāĻžāϰāĻŋāϤ⧇āχ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āφāϰ āϤāĻžāϰ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰāϟāĻžāϰ āĻĢāĻžāρāĻ• 32, āĻŽāĻžāύ⧇ āĻāĻ• āύāĻŽā§āĻŦāϰ āĻ•ā§ŒāĻļāϞāϟāĻž āĻšā§‹āϖ⧇āχ āĻĻ⧇āĻ–āĻž āϝāĻžāĻšā§āϛ⧇āĨ¤

48 āφāϰ 57-āϰ āĻĻāĻŋāϕ⧇ āϤāĻžāĻ•āĻžāĻ“āĨ¤ āĻ…āĻ™ā§āĻ•āϗ⧁āϞ⧋ āĻĢāĻžāρāĻ• āĻ›āĻžāĻĄāĻŧāĻž āĻ•ā§āϰāĻŽā§‡ āĻŦāϏāĻž, āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āĻĻ⧁āχ āύāĻŽā§āĻŦāϰ āĻ•ā§ŒāĻļāϞ āϕ⧇āĻŦāϞ '7'-āϰ āϜāĻ¨ā§āϝ āύāĻž, āĻĒā§āϰāϤāĻŋāϟāĻž āĻ…āĻ™ā§āϕ⧇āϰ āϜāĻ¨ā§āϝāχ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

ASCII-āϰ āĻŦāĻžāχāϰ⧇, āφāϰ āĻŦāĻžāĻ‚āϞāĻžāϰ āϜāĻ¨ā§āϝ āĻāϰ āĻŽāĻžāύ⧇ āϕ⧀

ASCII āϕ⧇āĻŦāϞ 0 āĻĨ⧇āϕ⧇ 127 āĻ āĻŋāĻ• āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ āĻāϟāĻž āϏāĻžāϤ bit-āϰ āϜāĻ¨ā§āϝ āĻŦāĻžāύāĻžāύ⧋āĨ¤ āĻāĻ•āϟāĻž byte-āĻ āφāϟ bit āĻĨāĻžāϕ⧇, āϤāĻžāχ 128 āĻĨ⧇āϕ⧇ 255 āĻ–āĻžāϞāĻŋ āĻĒāĻĄāĻŧ⧇ āĻ›āĻŋāϞ, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž vendor āϏ⧇āϟāĻž āύāĻŋāĻœā§‡āϰ āĻŽāϤ⧋ āĻ­āϰ⧇āϛ⧇āĨ¤ āĻ“āχ āĻ—ā§‹āϞāĻŽāĻžāϞāϟāĻžāϰ āύāĻžāĻŽ "extended ASCII", āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āĻāĻ•āχ file āĻ…āĻ¨ā§āϝ āĻŽā§‡āĻļāĻŋāύ⧇ āφāĻŦā§‹āϞāϤāĻžāĻŦā§‹āϞ āĻĻ⧇āĻ–āĻžāϤāĨ¤

Unicode āĻāϟāĻž āϏāĻžāϰāĻŋāϝāĻŧ⧇āϛ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻŋāĻĒāĻŋāϰ āĻĒā§āϰāϤāĻŋāϟāĻž character-āϕ⧇ āύāĻŋāĻœā§‡āϰ āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āĻĻāĻŋāϝāĻŧ⧇, āφāϰ UTF-8 āĻšāϞ⧋ āĻ“āχ āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋ byte āĻšāĻŋāϏ⧇āĻŦ⧇ āϰāĻžāĻ–āĻžāϰ āωāĻĒāĻžāϝāĻŧāĨ¤ ASCII āĻšāϞ⧋ āϤāĻžāϰ āĻĒā§āϰāĻĨāĻŽ 128āϟāĻž, āĻ…āĻŦāĻŋāĻ•āϞ, āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āĻĒ⧁āϰāύ⧋ file āĻāĻ–āύ⧋ āϚāϞ⧇āĨ¤

āĻāĻŦāĻžāϰ āϤ⧋āĻŽāĻžāϰ āϜāĻ¨ā§āϝ āϜāϰ⧁āϰāĻŋ āĻ…āĻ‚āĻļāϟāĻžāĨ¤ UTF-8-āĻ āĻāĻ•āϟāĻž āĻŦāĻžāĻ‚āϞāĻž āĻ…āĻ•ā§āώāϰ āύ⧇āϝāĻŧ āϤāĻŋāύ byte, āĻāĻ• āύāĻžāĨ¤ "āĻĸāĻžāĻ•āĻž" āĻļāĻŦā§āĻĻāϟāĻž āϚāĻžāϰ āĻ…āĻ•ā§āώāϰ āφāϰ āĻŦāĻžāϰ⧋ byte, āφāϰ strlen āωāĻ¤ā§āϤāϰ āĻĻ⧇āϝāĻŧ 12āĨ¤

āϤāĻžāχ āĻāĻ•āϟāĻž char āĻāĻ• byte āϧāϰ⧇, āĻāĻ• āĻ…āĻ•ā§āώāϰ āύāĻžāĨ¤ āϤāĻŋāύāϟāĻž āĻ•ā§ŒāĻļāϞ ASCII-āϰ āĻ…āĻ•ā§āώāϰ āφāϰ āĻ…āĻ™ā§āϕ⧇ āϚāϞ⧇āĨ¤ āĻŦāĻžāĻ‚āϞāĻž āϞ⧇āĻ–āĻžāϝāĻŧ āϚāϞ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ 32 āϝ⧋āĻ— āĻ•āϰāĻžāϰ āĻŽāϤ⧋ āĻāĻ•āϟāĻžāĻŽāĻžāĻ¤ā§āϰ āϏāĻ‚āĻ–ā§āϝāĻž āĻ“āĻ–āĻžāύ⧇ āύ⧇āχāĨ¤ āĻŦāĻžāĻ‚āϞāĻž āϞ⧇āĻ–āĻž āύāĻŋāϝāĻŧ⧇ āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ āĻ•āĻžāϜ Module 10-āϰ āĻŦāĻŋāώāϝāĻŧ, āφāϰ āϤāĻžāϤ⧇ āĻāĻ•āϟāĻž library āϞāĻžāϗ⧇āĨ¤

Example 1: āĻāĻ•āχ byte, āϚāĻžāϰ āϰāĻ•āĻŽā§‡

āĻĒ⧁āϰ⧋ āĻ­āĻžāĻŦāύāĻžāϟāĻž āĻĻ⧇āĻ–āĻžāύ⧋āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ programāĨ¤ āĻāĻ•āϟāĻž variable, āϚāĻžāϰ āϞāĻžāχāύ āĻ›āĻžāĻĒāĻž, āφāϰ āϕ⧋āĻĨāĻžāĻ“ āĻ•āĻŋāϛ⧁ āĻŦāĻĻāϞ⧇ āύ⧇āĻ“āϝāĻŧāĻž āύ⧇āχāĨ¤

#include <stdio.h>

int main(void)
{
    char letter = 'A';

    printf("As a character: %c\n", letter);
    printf("As a number:    %d\n", letter);
    printf("Add 1:          %c\n", letter + 1);
    printf("Add 32:         %c\n", letter + 32);
    return 0;
}
As a character: A
As a number:    65
Add 1:          B
Add 32:         a

1 āϝ⧋āĻ— āĻ•āϰāĻžāϝāĻŧ āĻŦāĻ°ā§āĻŖāĻŽāĻžāϞāĻžāϝāĻŧ āĻāĻ• āϘāϰ āĻāĻ—āĻŋāϝāĻŧ⧇āϛ⧇āĨ¤ 32 āϝ⧋āĻ— āĻ•āϰāĻžāϝāĻŧ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻĻāϞ āĻĨ⧇āϕ⧇ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻĻāϞ⧇ āϞāĻžāĻĢ āĻĻāĻŋāϝāĻŧ⧇āϛ⧇āĨ¤ āĻĻ⧁āχāϟāĻžāχ 65 āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻžāϰ āωāĻĒāϰ āϏāĻžāĻĻāĻžāĻŽāĻžāϟāĻž āĻšāĻŋāϏāĻžāĻŦāĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
Example 2: library āĻ›āĻžāĻĄāĻŧāĻžāχ case āĻŦāĻĻāϞ

āĻāĻ• āύāĻŽā§āĻŦāϰ āĻ•ā§ŒāĻļāϞ, āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āχāĨ¤ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻĻāĻŋāϕ⧇ āύāĻžāĻŽāϤ⧇ 32 āϝ⧋āĻ— āĻ•āϰ⧋, āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻĻāĻŋāϕ⧇ āωāĻ āϤ⧇ 32 āĻŦāĻŋāϝāĻŧā§‹āĻ— āĻ•āϰ⧋āĨ¤

#include <stdio.h>

int main(void)
{
    char upper = 'M';
    char lower = 'q';

    /* A small letter is exactly 32 above its capital. */
    printf("%c becomes %c\n", upper, upper + 32);
    printf("%c becomes %c\n", lower, lower - 32);
    return 0;
}
M becomes m
q becomes Q

Character-āϟāĻž āϏāĻ¤ā§āϝāĻŋāχ āĻ…āĻ•ā§āώāϰ āĻšāϞ⧇āχ āĻāϟāĻž āϚāϞ⧇āĨ¤ '5'-āϰ āωāĻĒāϰ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–ā§‹, āĻĒāĻžāĻŦ⧇ code 21, āĻāĻ•āϟāĻž āĻ…āĻĻ⧃āĻļā§āϝ control character, āφāϰ āĻāĻ•āϟāĻžāĻ“ warning āφāϏāĻŦ⧇ āύāĻžāĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
Example 3: āĻ…āĻ™ā§āϕ⧇āϰ character āϤāĻžāϰ āĻŽāĻžāύ āύāĻž

āĻĻ⧁āχ āύāĻŽā§āĻŦāϰ āĻ•ā§ŒāĻļāϞ, āφāϰ āϝ⧇ āϭ⧁āϞāϟāĻž āφāϟāĻ•āĻžāϤ⧇ āĻ“āϟāĻž āφāϛ⧇āĨ¤ '7' character-āϟāĻž āφāϏāϞ⧇ 55 āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž, āφāϰ 7 āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻž āϤ⧋āĻŽāĻžāϕ⧇ āĻŦ⧇āϰ āĻ•āϰ⧇ āύāĻŋāϤ⧇ āĻšāϝāĻŧāĨ¤

#include <stdio.h>

int main(void)
{
    char digit = '7';

    int wrong = digit;           /* 55, the ASCII code */
    int right = digit - '0';     /* 7, the value it stands for */

    printf("Wrong: %d\n", wrong);
    printf("Right: %d\n", right);
    printf("Squared: %d\n", right * right);
    return 0;
}
Wrong: 55
Right: 7
Squared: 49

āĻ“āχ - '0' āϞ⧇āĻ–āĻž āĻĨ⧇āϕ⧇ āĻ…āĻ™ā§āĻ• āĻĒāĻĄāĻŧāĻž āĻĒā§āϰāĻžāϝāĻŧ āĻĒā§āϰāϤāĻŋāϟāĻž program-āĻ āφāϏ⧇, āφāϰ āĻ•āĻŋāϛ⧁ āĻĒāĻĄāĻŧ⧇ āĻāĻŽāύ program-āϰ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ—āχ āϤāĻžāχāĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
Example 4: āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ āĻāĻŽāύ āĻ…āĻ°ā§āϧ⧇āĻ•āϟāĻž āύāĻŋāĻœā§‡ āϛ⧇āĻĒ⧇ āĻĻ⧇āĻ–ā§‹

āĻāϟāĻžāϝāĻŧ āĻāĻ•āϟāĻž loop āφāϛ⧇, āϝ⧇āϟāĻž Module 6-āϰ āĻŦāĻŋāώāϝāĻŧāĨ¤ āĻĒāĻĄāĻŧā§‹, āϚāĻžāϞāĻžāĻ“, āφāϰ āĻāĻ–āύāχ āύāĻŋāĻœā§‡ āϞ⧇āĻ–āĻžāϰ āĻ•āĻĨāĻž āĻ­āĻžāĻŦāϤ⧇ āĻšāĻŦ⧇ āύāĻžāĨ¤ āφāϏāϞ āĻ•āĻĨāĻžāϟāĻž āĻšāϞ⧋, āωāĻĒāϰ⧇āϰ table āĻŦāĻŋāĻļā§āĻŦāĻžāϏ āĻ•āϰāĻžāϰ āĻŽāϤ⧋ āĻāĻ•āϟāĻž āϤāĻĨā§āϝ āύāĻž, āĻ“āϟāĻž āϤ⧋āĻŽāĻžāϰ āĻŽā§‡āĻļāĻŋāύāχ āϤ⧋āĻŽāĻžāϕ⧇ āϛ⧇āĻĒ⧇ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

#include <stdio.h>

int main(void)
{
    for (int code = 32; code <= 126; code++) {
        printf("%3d %c", code, code);

        /* Start a new line after every eighth entry. */
        if ((code - 31) % 8 == 0) {
            printf("\n");
        } else {
            printf("   ");
        }
    }
    printf("\n");
    return 0;
}
 32      33 !    34 "    35 #    36 $    37 %    38 &    39 '
 40 (    41 )    42 *    43 +    44 ,    45 -    46 .    47 /
 48 0    49 1    50 2    51 3    52 4    53 5    54 6    55 7
 56 8    57 9    58 :    59 ;    60 <    61 =    62 >    63 ?
 64 @    65 A    66 B    67 C    68 D    69 E    70 F    71 G
 72 H    73 I    74 J    75 K    76 L    77 M    78 N    79 O
 80 P    81 Q    82 R    83 S    84 T    85 U    86 V    87 W
 88 X    89 Y    90 Z    91 [    92 \    93 ]    94 ^    95 _
 96 `    97 a    98 b    99 c   100 d   101 e   102 f   103 g
104 h   105 i   106 j   107 k   108 l   109 m   110 n   111 o
112 p   113 q   114 r   115 s   116 t   117 u   118 v   119 w
120 x   121 y   122 z   123 {   124 |   125 }   126 ~

āĻĒā§āϰāĻĨāĻŽ āϘāϰāϟāĻž āĻ­āĻžāĻ™āĻž āĻŽāύ⧇ āĻšāϝāĻŧ, āφāϰ āĻ­āĻžāĻ™āĻž āύāĻžāĨ¤ Code 32 āĻšāϞ⧋ space character, āϤāĻžāχ āĻ“āϟāĻž āĻāĻ•āϟāĻž space-āχ āĻ›āĻžāĻĒ⧇āĨ¤ %c-āϕ⧇ %x āĻ•āϰ⧇ āĻĻāĻŋāϞ⧇ table-āϟāĻž hexadecimal-āĻ āĻĒāĻžāĻŦ⧇āĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“

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

  • āϤ⧋āĻŽāĻžāϰ āĻŽā§‡āĻļāĻŋāύ⧇āϰ āĻĒā§āϰāϤāĻŋāϟāĻž text file. āĻāĻ•āϟāĻž .c file, āĻāĻ•āϟāĻž .csv file āφāϰ āĻāχ page-āϰ HTML, āϏāĻŦāχ āĻāχ code-āϗ⧁āϞ⧋āϰ āϏāĻžāϰ, āφāϰ 127-āϰ āωāĻĒāϰ⧇āϰ āϏāĻŦ āĻ•āĻŋāϛ⧁ āϏāĻžāĻŽāϞāĻžāϝāĻŧ UTF-8āĨ¤
  • HTTP. GET /index.html HTTP/1.1-āϰ āĻŽāϤ⧋ āĻāĻ•āϟāĻž request line āĻšāϞ⧋ ASCII āϞ⧇āĻ–āĻž, āĻļ⧇āώ āĻšāϝāĻŧ CR āφāϰ LF āĻĻāĻŋāϝāĻŧ⧇, āĻŽāĻžāύ⧇ code 13 āφāϰ 10āĨ¤ āϏ⧇āϜāĻ¨ā§āϝāχ āφāϞāĻžāĻĻāĻž āĻ­āĻžāώāĻžāϝāĻŧ āϞ⧇āĻ–āĻž browser āφāϰ server āĻ•āĻĨāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
  • āϤ⧋āĻŽāĻžāϰ keyboard. Ctrl āφāϰ C āϚāĻžāĻĒāϞ⧇ āϝāĻžāϝāĻŧ code 3, ETX, āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āϤ⧋āĻŽāĻžāϰ laptop āϜāĻ¨ā§āĻŽāĻžāύ⧋āϰ āĻ…āύ⧇āĻ• āφāϗ⧇ āĻĨ⧇āϕ⧇āχ āĻ“āχ āĻœā§‹āĻĄāĻŧāĻžāϟāĻžāϰ āĻŽāĻžāύ⧇ "āĻĨāĻžāĻŽā§‹"āĨ¤
  • āύāĻžāĻŽ āϏāĻžāϜāĻžāύ⧋. āϞ⧇āĻ–āĻž āĻŽā§‡āϞāĻžāύ⧋ āĻŽāĻžāύ⧇ āĻāχ code-āϗ⧁āϞ⧋ āĻŽā§‡āϞāĻžāύ⧋, āφāϰ 'Z' āĻšāϞ⧋ 90 āϝāĻ–āύ 'a' āĻšāϞ⧋ 97āĨ¤ āϤāĻžāχ āϏāĻžāĻĻāĻžāĻŽāĻžāϟāĻž āĻāĻ•āϟāĻž sort āĻĒā§āϰāϤāĻŋāϟāĻž āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāϕ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž āϛ⧋āϟ āĻšāĻžāϤ⧇āϰāϟāĻžāϰ āφāϗ⧇ āĻŦāϏāĻžāϝāĻŧ, āφāϰ āϏ⧇āϜāĻ¨ā§āϝāχ āϏāĻ¤ā§āϝāĻŋāĻ•āĻžāϰ⧇āϰ software case āύāĻž āĻĻ⧇āĻ–āĻž function āĻĻāĻŋāϝāĻŧ⧇ sort āĻ•āϰ⧇āĨ¤

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

ā§§. āĻ…āĻ™ā§āϕ⧇āϰ character-āϕ⧇āχ āϤāĻžāϰ āĻŽāĻžāύ āϧāϰ⧇ āύ⧇āĻ“āϝāĻŧāĻžāĨ¤

char digit = '7';
printf("%d\n", digit);        /* prints 55, not 7 */

āϕ⧋āύ⧋ message āύ⧇āχāĨ¤ GCC āĻ āĻŋāĻ•āχ āĻŦāϞāϛ⧇ āϝ⧇ char āϛ⧋āϟ āĻāĻ•āϟāĻž integer, āφāϰ 55 āϏ⧇āχ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻžāχ āϝ⧇āϟāĻž āϤ⧁āĻŽāĻŋ āĻšā§‡āϝāĻŧ⧇āĻ›āĨ¤ āĻŽāĻžāύ āϚāĻžāχāϞ⧇ āϏāĻŦ āϏāĻŽāϝāĻŧ '0' āĻŦāĻŋāϝāĻŧā§‹āĻ— āĻ•āϰ⧋āĨ¤

⧍. āĻ…āĻ•ā§āώāϰ āύāĻž, āĻāĻŽāύ āĻ•āĻŋāϛ⧁āϰ āωāĻĒāϰ case-āϰ āĻšāĻŋāϏāĻžāĻŦ āϚāĻžāϞāĻžāύ⧋āĨ¤

char d = '5';
printf("[%c]\n", d - 32);     /* prints [ ] with an invisible control char */

āĻāĻ–āĻžāύ⧇āĻ“ āϕ⧋āύ⧋ message āύ⧇āχ, warning-āϰ āϕ⧋āύ⧋ āĻ¸ā§āϤāϰ⧇āχāĨ¤ 53 āĻĨ⧇āϕ⧇ 32 āĻŦāĻžāĻĻ āĻĻāĻŋāϞ⧇ 21, āĻŽāĻžāύ⧇ NAK, āĻ…āĻĻ⧃āĻļā§āϝāĨ¤ Character-āϟāĻž āφāϗ⧇ āϝāĻžāϚāĻžāχ āĻ•āϰāĻžāϰ if āĻĒāĻžāĻŦ⧇ Module 5-āĻāĨ¤

ā§Š. āĻāĻ•āϟāĻž char-āĻ āĻŦāĻžāĻ‚āϞāĻž āĻ…āĻ•ā§āώāϰ āĻŦāϏāĻžāύ⧋āĨ¤

char c = 'āĻĸ';
printf("%d\n", c);

GCC 12 āϤ⧋āĻŽāĻžāϕ⧇ āĻĻ⧁āχāϟāĻž warning āĻĻ⧇āϝāĻŧ: warning: multi-character character constant āφāϰ warning: overflow in conversion from 'int' to 'char' changes value from '14722722' to '-94'āĨ¤ āϤāĻžāϰāĻĒāϰ āĻ›āĻžāĻĒ⧇ -94āĨ¤ āĻāĻ•āϟāĻž char āĻāĻ• byte, āφāϰ āĻ“āχ āĻ…āĻ•ā§āώāϰ⧇āϰ āϞāĻžāϗ⧇ āϤāĻŋāύ byteāĨ¤

ā§Ē. char-āĻ āϧāϰ⧇ āύāĻž āĻāĻŽāύ āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āϰāĻžāĻ–āĻžāĨ¤

char c = 300;
printf("%d\n", c);            /* prints 44 */

GCC 12 āĻŦāϞ⧇ warning: overflow in conversion from 'int' to 'char' changes value from '300' to '44', āφāϰ āϤāĻŦ⧁āĻ“ build āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāχ āĻŽā§‡āĻļāĻŋāύ⧇ āĻāĻ•āϟāĻž char -128 āĻĨ⧇āϕ⧇ 127 āϧāϰ⧇, āφāϰ āĻ āĻŋāĻ• āϏ⧇āϜāĻ¨ā§āϝāχ ASCII 127-āĻ āĻĨ⧇āĻŽā§‡ āϗ⧇āϛ⧇āĨ¤

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

Kenji āĻŦāϞāϛ⧇ character āϤ⧋ āϏāĻ‚āĻ–ā§āϝāĻžāχ, āϤāĻžāχ āĻĻ⧁āχāϟāĻž āϝ⧋āĻ— āĻ•āϰāϞ⧇ āϏāĻŽāĻ¸ā§āϝāĻž āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻĨāĻž āύāĻžāĨ¤ Zara āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻŽāĻžāύāϛ⧇ āύāĻžāĨ¤

printf("%d\n", 'a' + 'b');
printf("[%c]\n", 'a' + 'b');

āϤāĻŋāύāϟāĻž āĻĒā§āϰāĻļā§āύ⧇āϰ āωāĻ¤ā§āϤāϰ āĻĻāĻžāĻ“āĨ¤ āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύāϟāĻž āϕ⧀ āĻ›āĻžāĻĒ⧇? āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύāϟāĻž āϕ⧀ āĻ›āĻžāĻĒ⧇, āφāϰ āĻ“āϟāĻž āϕ⧇āύ āϕ⧋āύ⧋ āĻ…āĻ•ā§āώāϰ āύāĻž? āφāϰ āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ āĻāĻŽāύ āϕ⧋āύ āĻĻ⧁āχāϟāĻž ASCII character-āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āĻœā§‹āĻĄāĻŧāĻžāϰ āϝ⧋āĻ—āĻĢāϞ āĻāĻ–āύ⧋ āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ āĻāĻŽāύ āĻāĻ•āϟāĻž ASCII character?

Table-āĻ āĻĻ⧁āχāϟāĻž code āĻĻ⧇āϖ⧇ āύāĻžāĻ“, āφāϰ āĻ•āĻžāĻ—āĻœā§‡ āϝ⧋āĻ— āĻ•āϰ⧋āĨ¤ āϤāĻžāϰāĻĒāϰ āĻ­āĻžāĻŦā§‹, table-āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ code āĻ•āϤ, āφāϰ āϤāĻžāϰ āĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āϏāĻ‚āĻ–ā§āϝāĻž āύāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž byte āϕ⧀ āĻ•āϰ⧇āĨ¤

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

Maria āĻāĻŽāύ āĻāĻ•āϟāĻž tool āĻŦāĻžāύāĻžāĻšā§āϛ⧇, āϝ⧇āϟāĻž āϝ⧇āϕ⧋āύ⧋ key-āϰ code āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤ āĻāĻ•āϟāĻž character āĻĒāĻĄāĻŧā§‹, āφāϰ āϤāĻžāϰ decimal code āĻ›āĻžāĻĒā§‹āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻ āĻŋāĻ• āĻāĻ•āϟāĻž character, āϝ⧇āϟāĻž space-āĻ“ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āĻ“āϟāĻžāϰ decimal ASCII codeāĨ¤

Constraints. Character-āϟāĻž āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ āĻāĻŽāύ ASCII, code 32 āĻĨ⧇āϕ⧇ 126āĨ¤

Sample. Input A āĻĻāĻŋāϞ⧇ āφāϏ⧇ 65āĨ¤ Input āĻāĻ•āϟāĻž space āĻĻāĻŋāϞ⧇ āφāϏ⧇ 32āĨ¤

#include <stdio.h>

int main(void)
{
    char ch;
    scanf("%c", &ch);

    /* One printf. Which specifier do you need? */

    return 0;
}

āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋, scanf("%c", &ch)-āϤ⧇ %c-āϰ āφāϗ⧇ āϕ⧋āύ⧋ space āύ⧇āχāĨ¤ āĻāϟāĻž āχāĻšā§āĻ›āĻž āĻ•āϰ⧇āχ: āĻ“āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻž space āĻĨāĻžāĻ•āϞ⧇ āĻ“āϟāĻž space character-āϟāĻž āĻāĻĄāĻŧāĻŋāϝāĻŧ⧇ āϝ⧇āϤ, āφāϰ space-āĻ“ āĻāĻ•āϟāĻž test caseāĨ¤

Hidden test āϏāĻš grading āĻšāϝāĻŧ āĻāχ module-āϰ Problems lesson-āĻ, char-code āύāĻžāĻŽā§‡āĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
āĻ…āύ⧁āĻļā§€āϞāύ ⧍āϏāĻšāϜ

āϕ⧇āĻŦāϞ āĻšāĻŋāϏāĻžāĻŦ āĻĻāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž āĻ…āĻ•ā§āώāϰ⧇āϰ case āĻŦāĻĻāϞāĻžāĻ“āĨ¤ āϕ⧋āύ⧋ library function āύāĻž, āϕ⧋āύ⧋ if āύāĻžāĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ, 'A' āĻĨ⧇āϕ⧇ 'Z'āĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āϏ⧇āχ āĻ…āĻ•ā§āώāϰāϟāĻžāχ āϛ⧋āϟ āĻšāĻžāϤ⧇āĨ¤

Constraints. Input āϏāĻŦ āϏāĻŽāϝāĻŧ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ, āϤāĻžāχ āϕ⧋āύ⧋ āϝāĻžāϚāĻžāχ āϞāĻžāĻ—āĻŦ⧇ āύāĻžāĨ¤

Sample. Input M āĻĻāĻŋāϞ⧇ āφāϏ⧇ māĨ¤

#include <stdio.h>

int main(void)
{
    char ch;
    scanf("%c", &ch);

    /* Trick one. Write the 32 as a difference of two characters if you can. */

    return 0;
}

āύāĻŋāĻœā§‡ āϝāĻžāϚāĻžāχ āĻ•āϰ⧋āĨ¤ A āφāϰ Z āĻĻāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–ā§‹, āĻŽāĻžāύ⧇ āĻĻ⧁āχ āĻŽāĻžāĻĨāĻžāĨ¤ āĻĻ⧁āχāϟāĻžāχ āϚāϞāϞ⧇ āĻŽāĻžāĻā§‡āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻ…āĻ•ā§āώāϰāĻ“ āϚāϞāĻŦ⧇, āĻ•āĻžāϰāĻŖ table-āĻ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāϗ⧁āϞ⧋ āĻ…āĻŦāĻŋāĻšā§āĻ›āĻŋāĻ¨ā§āύāĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
āĻ…āύ⧁āĻļā§€āϞāύ ā§ŠāĻŽāĻžāĻāĻžāϰāĻŋ

Amara āĻāĻŽāύ āĻāĻ•āϟāĻž form āĻŽā§‡āϞāĻžāĻšā§āϛ⧇, āϝ⧇āĻ–āĻžāύ⧇ āϤāĻŋāύāϟāĻž āĻ…āĻ™ā§āĻ• character āĻšāĻŋāϏ⧇āĻŦ⧇ āφāϏ⧇, āĻŽāĻžāĻā§‡ āĻ•āĻŋāϛ⧁ āύ⧇āχāĨ¤ āĻ“āϰāĻž āϝāĻž āĻŦā§‹āĻāĻžāϝāĻŧ, āϏ⧇āϗ⧁āϞ⧋ āϝ⧋āĻ— āĻ•āϰ⧋āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻ āĻŋāĻ• āϤāĻŋāύāϟāĻž āĻ…āĻ™ā§āϕ⧇āϰ character, āϕ⧋āύ⧋ space āύ⧇āχāĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ āϤāĻŋāύāϟāĻž āĻ…āĻ™ā§āϕ⧇āϰ āĻŽāĻžāύ⧇āϰ āϝ⧋āĻ—āĻĢāϞāĨ¤

Constraints. āĻĒā§āϰāϤāĻŋāϟāĻž character '0' āĻĨ⧇āϕ⧇ '9'āĨ¤

Sample. Input 407 āĻĻāĻŋāϞ⧇ āφāϏ⧇ 11, āĻ•āĻžāϰāĻŖ 4 āφāϰ 0 āφāϰ 7 āĻŽāĻŋāϞ⧇ 11āĨ¤

#include <stdio.h>

int main(void)
{
    char a, b, c;
    scanf("%c%c%c", &a, &b, &c);

    /* Trick two, three times. */

    return 0;
}

āύāĻŋāĻœā§‡ āϝāĻžāϚāĻžāχ āĻ•āϰ⧋āĨ¤ 000 āĻĻāĻŋāϞ⧇ 0 āφāϰ 999 āĻĻāĻŋāϞ⧇ 27 āφāϏāϤ⧇āχ āĻšāĻŦ⧇āĨ¤ 000 āĻĻāĻŋāϝāĻŧ⧇ 144 āĻĒ⧇āϞ⧇ āĻŦ⧁āĻāĻŦ⧇ āϤ⧁āĻŽāĻŋ āĻŽāĻžāύ⧇āϰ āĻŦāĻĻāϞ⧇ code āϝ⧋āĻ— āĻ•āϰ⧇āĻ›āĨ¤

Grading āĻšāϝāĻŧ digit-sum-three āύāĻžāĻŽā§‡āĨ¤

Compiler-āĻ āϚāĻžāϞāĻžāĻ“
āĻ…āύ⧁āĻļā§€āϞāύ ā§ĒāĻ•āĻ āĻŋāύ

ROT13 āĻšāϞ⧋ āϞ⧇āĻ–āĻž āϞ⧁āĻ•āĻžāύ⧋āϰ āϖ⧁āĻŦ āĻĒ⧁āϰāύ⧋ āĻāĻ•āϟāĻž āωāĻĒāĻžāϝāĻŧ: āĻĒā§āϰāϤāĻŋāϟāĻž āĻ…āĻ•ā§āώāϰ⧇āϰ āĻŦāĻĻāϞ⧇ 13 āϘāϰ āĻĒāϰ⧇āϰ āĻ…āĻ•ā§āώāϰāϟāĻž āĻŦāϏāĻžāĻ“, āφāϰ z āĻĒ⧇āϰāĻŋāϝāĻŧ⧇ āϗ⧇āϞ⧇ āφāĻŦāĻžāϰ a āĻĨ⧇āϕ⧇ āĻ—ā§‹āύ⧋āĨ¤ āĻāĻ•āϟāĻž āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇āϰ āϜāĻ¨ā§āϝ āĻāϟāĻž āĻ•āϰ⧋āĨ¤

Input. āĻāĻ• āϞāĻžāχāύ⧇ āĻāĻ•āϟāĻž āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ, 'a' āĻĨ⧇āϕ⧇ 'z'āĨ¤

Output. āĻāĻ• āϞāĻžāχāύ⧇ 13 āϘāϰ āĻĒāϰ⧇āϰ āĻ…āĻ•ā§āώāϰāϟāĻž, āĻŦāĻ°ā§āĻŖāĻŽāĻžāϞāĻžāϰ āϭ⧇āϤāϰ⧇ āϘ⧁āϰāĻŋāϝāĻŧ⧇ āφāύāĻžāĨ¤

Constraints. Input āϏāĻŦ āϏāĻŽāϝāĻŧ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāĨ¤

Sample. Input a āĻĻāĻŋāϞ⧇ āφāϏ⧇ nāĨ¤ Input z āĻĻāĻŋāϞ⧇ āφāϏ⧇ māĨ¤

āĻ•āĻ āĻŋāύ āĻ…āĻ‚āĻļāϟāĻž āĻšāϞ⧋ āϘ⧁āϰ⧇ āφāϏāĻžāĨ¤ 'z'-āϤ⧇ 13 āϝ⧋āĻ— āĻ•āϰāϞ⧇ āĻŦāĻ°ā§āĻŖāĻŽāĻžāϞāĻžāϰ āĻŦāĻžāχāϰ⧇ āϚāϞ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻāĻ• āϞāĻžāχāύ āĻšāĻŋāϏāĻžāĻŦ⧇āχ āĻāϟāĻž āϏāĻžāϰ⧇, āĻ­āĻžāĻ—āĻļ⧇āώ⧇āϰ operator % āφāϰ āϤāĻŋāύ āύāĻŽā§āĻŦāϰ āĻ•ā§ŒāĻļāϞ⧇āϰ āĻŦāĻ°ā§āĻŖāĻŽāĻžāϞāĻžāϰ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāύ āĻĻāĻŋāϝāĻŧ⧇āĨ¤ āĻ­āĻžāĻ—āĻļ⧇āώ⧇āϰ operator Module 4-āϰ, āφāϰ āφāϗ⧇āχ āĻ“āϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϚāϞāĻŦ⧇āĨ¤

āύāĻŋāĻœā§‡ āϝāĻžāϚāĻžāχ āĻ•āϰ⧋āĨ¤ a, m, n āφāϰ z āĻĻāĻŋāϝāĻŧ⧇ āϚāĻžāϞāĻžāĻ“āĨ¤ āĻāĻ•āχ āĻ…āĻ•ā§āώāϰ⧇ āϤ⧋āĻŽāĻžāϰ program āĻĻ⧁āχāĻŦāĻžāϰ āϚāĻžāϞāĻžāϞ⧇ āĻ…āĻ•ā§āώāϰāϟāĻž āĻĢāĻŋāϰ⧇ āφāϏāϤ⧇ āĻšāĻŦ⧇, āφāϰ āĻāχ āϧāĻ°ā§āĻŽāϟāĻžāχ ROT13-āϕ⧇ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ āĻ•āϰ⧇āĻ›āĻŋāϞāĨ¤

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

  • 128āϟāĻž code āϕ⧇āύ, 256 āϕ⧇āύ āύāĻž?

    ASCII āϏāĻžāϤ bit-āϰ āϜāĻ¨ā§āϝ āĻŦāĻžāύāĻžāύ⧋, āĻāĻŽāύ āĻāĻ•āϟāĻž āϏāĻŽāϝāĻŧ⧇ āϝāĻ–āύ āĻ…āĻˇā§āϟāĻŽ bit āϭ⧁āϞ āϝāĻžāϚāĻžāχāϝāĻŧ⧇ āϞāĻžāĻ—āϤāĨ¤ 127-āϰ āωāĻĒāϰ⧇āϰ āĻ–āĻžāϞāĻŋ āĻ…āĻ°ā§āϧ⧇āĻ•āϟāĻž āĻĒā§āϰāϤāĻŋāϟāĻž vendor āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āĻ­āϰ⧇āϛ⧇, āφāϰ āĻ“āχ āĻ—ā§‹āϞāĻŽāĻžāϞ⧇āϰ āϜāĻžāϝāĻŧāĻ—āĻž āύāĻŋāϝāĻŧ⧇āϛ⧇ UnicodeāĨ¤

  • āĻāĻ•āϟāĻž char signed āύāĻž unsigned?

    Standard āĻāϟāĻž compiler-āϰ āĻšāĻžāϤ⧇ āϛ⧇āĻĄāĻŧ⧇ āĻĻāĻŋāϝāĻŧ⧇āϛ⧇, āφāϰ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— āĻŽā§‡āĻļāĻŋāύ⧇ āĻāϟāĻž signed, āĻŽāĻžāύ⧇ -128 āĻĨ⧇āϕ⧇ 127āĨ¤ 0 āĻĨ⧇āϕ⧇ 127-āϰ code-āϰ āϜāĻ¨ā§āϝ āĻāϤ⧇ āĻ•āĻŋāϛ⧁ āφāϏ⧇ āϝāĻžāϝāĻŧ āύāĻž, āφāϰ ASCII āϤ⧋ āĻ“āϟ⧁āϕ⧁āχāĨ¤

  • 'A'-āϰ āĻŦāĻĻāϞ⧇ 65 āϞ⧇āĻ–āĻž āϝāĻžāϝāĻŧ?

    āϝāĻžāϝāĻŧ, āφāϰ program āĻšā§āĻŦāĻšā§ āĻāĻ•āχ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āϞāĻŋāĻ–ā§‹ āύāĻž: 'A' āϤ⧁āĻŽāĻŋ āϝāĻž āĻŦāϞāϤ⧇ āϚāĻžāĻ“ āϏ⧇āϟāĻžāχ āĻŦāϞ⧇, āĻ›āϝāĻŧ āĻŽāĻžāϏ āĻĒāϰ⧇ āĻĒāĻĄāĻŧāϞ⧇āĻ“ āĻŸā§‡āϕ⧇, āφāϰ āϝ⧇āϏāĻŦ āĻŽā§‡āĻļāĻŋāύ⧇ code āφāϞāĻžāĻĻāĻž āϏ⧇āĻ–āĻžāύ⧇āĻ“ āϚāϞ⧇āĨ¤

  • Table-āĻ hexadecimal-āĻ“ āĻĻ⧇āĻ“āϝāĻŧāĻž āϕ⧇āύ?

    āĻ•āĻžāϰāĻŖ tool āϤ⧋āĻŽāĻžāϕ⧇ byte āĻĻ⧇āĻ–āĻžāϝāĻŧ hex-āĻāĨ¤ āĻāĻ•āϟāĻž memory dump, āĻāĻ•āϟāĻž network capture āφāϰ \x41-āϰ āĻŽāϤ⧋ āĻāĻ•āϟāĻž escape, āϏāĻŦāχ base 16 āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤ āĻ“āχ āϜāĻžāϝāĻŧāĻ—āĻžāϗ⧁āϞ⧋āϤ⧇ 65-āϰ āĻšā§‡āϝāĻŧ⧇ 41 āϚāĻŋāύāϤ⧇ āϏāĻšāϜāĨ¤

  • āϤāĻŋāύāϟāĻž āĻ•ā§ŒāĻļāϞ āĻ•āĻŋ āĻŦāĻžāĻ‚āϞāĻž āĻ…āĻ•ā§āώāϰ⧇ āϚāϞ⧇?

    āύāĻžāĨ¤ UTF-8-āĻ āĻāĻ•āϟāĻž āĻŦāĻžāĻ‚āϞāĻž āĻ…āĻ•ā§āώāϰ āϤāĻŋāύ byte, āϤāĻžāχ 32 āϝ⧋āĻ— āĻ•āϰāĻžāϰ āĻŽāϤ⧋ āĻāĻ•āϟāĻžāĻŽāĻžāĻ¤ā§āϰ āϏāĻ‚āĻ–ā§āϝāĻž āύ⧇āχāĨ¤ āĻāĻ•āϟāĻž text library āϞāĻžāĻ—āĻŦ⧇, āφāϰ āĻāĻ•āϟāĻž C string āϕ⧀ āĻĒāĻžāϰ⧇ āφāϰ āϕ⧀ āĻĒāĻžāϰ⧇ āύāĻž, āϏ⧇āϟāĻž āĻŦā§‹āĻāĻžāϝāĻŧ Module 10āĨ¤

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

  • āĻāĻ•āϟāĻž char āϛ⧋āϟ āĻāĻ•āϟāĻž integer; %c āφāϰ %d āĻšāϞ⧋ āĻāĻ•āχ byte-āϰ āωāĻĒāϰ āĻĻ⧁āχāϟāĻž āĻ•āĻžāϚāĨ¤
  • āϚāĻžāϰāϟāĻž āύ⧋āĻ™āϰ āĻĒ⧁āϰ⧋ table āĻŦāχāϛ⧇: 48, 65, 97 āφāϰ 32āĨ¤
  • āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻĨ⧇āϕ⧇ āϛ⧋āϟ āĻšāĻžāϤ⧇ āϝ⧇āϤ⧇ 32 āϝ⧋āĻ—; āĻ…āĻ™ā§āϕ⧇āϰ character āĻĨ⧇āϕ⧇ āĻŽāĻžāύ āĻĒ⧇āϤ⧇ '0' āĻŦāĻŋāϝāĻŧā§‹āĻ—; āĻ…āĻ•ā§āώāϰ āĻĨ⧇āϕ⧇ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāύ āĻĒ⧇āϤ⧇ 'A' āĻŦāĻŋāϝāĻŧā§‹āĻ—āĨ¤
  • 0 āĻĨ⧇āϕ⧇ 31 āĻšāϞ⧋ control character, āφāϰ āĻ“āĻĻ⧇āϰ āĻĒāĻžāρāϚāϟāĻž āĻāĻ–āύ⧋ āϰ⧋āϜ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧāĨ¤
  • āĻ…āĻ™ā§āĻ•, āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āφāϰ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ, āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻāϞ āĻ…āĻŦāĻŋāĻšā§āĻ›āĻŋāĻ¨ā§āύ āĻāĻ• āϏāĻžāϰāĻŋāϤ⧇ āĻŦāϏāĻžāĨ¤
  • ASCII āĻĨāĻžāĻŽā§‡ 127-āĻ; āĻāĻ•āϟāĻž āĻŦāĻžāĻ‚āϞāĻž āĻ…āĻ•ā§āώāϰ āϤāĻŋāύ UTF-8 byte, āϤāĻžāχ āĻ•ā§ŒāĻļāϞāϗ⧁āϞ⧋ āĻ“āĻ–āĻžāύ⧇ āĻĒ⧌āρāĻ›āĻžāϝāĻŧ āύāĻžāĨ¤

āĻĒāϰ⧇āϰ lesson-āĻ āϤ⧁āĻŽāĻŋ āĻāĻŽāύ code āϞāĻŋāĻ–āĻŦ⧇ āϝ⧇āϟāĻž āφāϰ⧇āĻ•āϜāύ āĻŽāĻžāύ⧁āώ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāχ module-āĻ āĻ“āϟāĻžāχ āĻāĻ•āϟāĻžāĻŽāĻžāĻ¤ā§āϰ āĻĻāĻ•ā§āώāϤāĻž, āϝ⧇āϟāĻž compiler āϤ⧋āĻŽāĻžāϰ āĻšāϝāĻŧ⧇ āĻ•āĻ–āύ⧋ āϝāĻžāϚāĻžāχ āĻ•āϰāĻŦ⧇ āύāĻžāĨ¤

lesson ā§Ē āĻļ⧇āώ

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

āĻĒāϰ⧇āϰāϟāĻž: Comment, whitespace āφāϰ āĻŽāĻžāύ⧁āώ⧇āϰ āĻĒāĻĄāĻŧāĻžāϰ āĻŽāϤ⧋ code