C పరిచయం, చరిత్ర & మొదటి ప్రోగ్రామ్ (Hello World)
1960ల చివరలో కంప్యూటర్లు భారీ గదులంత పరిమాణంలో ఉండేవి. ఆ రోజుల్లో ఒక కంప్యూటర్‌కు ప్రోగ్రామ్ రాయాలంటే అసెంబ్లీ లాంగ్వేజ్ (Assembly Language) లోని కష్టతరమైన మెషిన్ సూచనలను ఉపయోగించాల్సి వచ్చేది. ఒక కంప్యూటర్ మోడల్ కోసం రాసిన కోడ్ మరొక మోడల్‌పై అస్సలు పనిచేసేది కాదు. ఈ తీవ్రమైన సమస్యను పరిష్కరించి, ప్రపంచ సాంకేతిక చరిత్రను శాశ్వతంగా మార్చివేసిన ఒక అద్భుత సృష్టి — C ప్రోగ్రామింగ్ లాంగ్వేజ్!
1972 లో అమెరికాలోని ప్రసిద్ధ బెల్ లాబొరేటరీస్ (Bell Labs) లో లెజెండరీ కంప్యూటర్ శాస్త్రవేత్త Dennis Ritchie (డెన్నిస్ రిట్చీ) C భాషను రూపొందించారు. కేవలం UNIX ఆపరేటింగ్ సిస్టమ్‌ను నిర్మించడానికి పుట్టిన ఈ భాష — అనతికాలంలోనే ఆధునిక సాఫ్ట్‌వేర్ సామ్రాజ్యానికి పునాదిరాయిగా మారింది. నేడు మనం వాడుతున్న Windows OS, Linux, Android, iOS, మరియు ఆధునిక ప్రోగ్రామింగ్ భాషలైన C++, Java, Python, C#, Go, Rust లన్నింటి మూలాలూ C తోనే ముడిపడి ఉన్నాయి!
ఈ ప్రారంభ అధ్యాయంలో, కంప్యూటర్ మెమరీ మరియు సిలికాన్ చిప్ స్థాయిలోకి తొంగిచూస్తూ — C భాష ఎందుకు అన్ని భాషలకూ తల్లి (Mother of Programming) అయ్యిందో, GCC కంపైలర్ మీ కోడ్‌ను మెషిన్ లాంగ్వేజ్‌గా ఎలా మారుస్తుందో, మరియు మీ మొదటి C ప్రోగ్రామ్ యొక్క ప్రతి అక్షరం వెనుక దాగి ఉన్న అంతర్గత రహస్యాలను లోతుగా అన్వేషిద్దాం!
- C లాంగ్వేజ్ పుట్టుక & చరిత్ర: Dennis Ritchie, Ken Thompson మరియు UNIX ఆపరేటింగ్ సిస్టమ్ విప్లవం.
- C లాంగ్వేజ్ యొక్క 4 ప్రాథమిక స్తంభాలు: డైరెక్ట్ మెమరీ యాక్సెస్, జీరో రన్‌టైమ్ ఓవర్‌హెడ్, పోర్టబిలిటీ, మరియు డిటర్మినిస్టిక్ పెర్ఫార్మెన్స్.
- GCC కంపైలర్ పైప్‌లైన్ (4 Stages): ప్రీప్రాసెసింగ్, కంపైలేషన్, అసెంబ్లీ, మరియు లింకింగ్ లోతైన విశ్లేషణ.
- మొదటి C ప్రోగ్రామ్ అనాటమీ: Hello, World! ప్రోగ్రామ్ మరియు ప్రతి లైన్ యొక్క లోతైన అర్థం.
- #include <stdio.h> రహస్యం: Preprocessor Directives మరియు C స్టాండర్డ్ లైబ్రరీ హెడర్ ఫైల్స్.
- int main(void) ఎంట్రీ పాయింట్: CPU మరియు OS మీ ప్రోగ్రామ్‌ను ఎలా ప్రారంభిస్తాయి?
- printf() ఫంక్షన్ పనితీరు: ఫార్మాట్ స్ట్రింగ్స్, బఫరింగ్, మరియు ఎస్కేప్ సీక్వెన్సెస్ (
\n,\t). - return 0; ప్రాముఖ్యత: ఆపరేటింగ్ సిస్టమ్‌కు సక్సెస్ స్టేటస్ కోడ్ పంపడం.
- void main() మిత్ బద్దలు: అంతర్జాతీయ ప్రమాణాల ప్రకారం (C99/C11/C17)
void main()ఎందుకు తప్పు? - బిగినర్స్ చేసే ఘోరమైన తప్పులు: కామన్ సింటాక్స్ ఎర్రర్లు మరియు వాటిని నివారించే మార్గాలు.
- ఆధునిక ఇంటరాక్టివ్ క్విజ్: మీ ఆలోచనను పరీక్షించే 5 లోతైన ప్రశ్నలు.
1960ల చివరలో MIT, Bell Labs, మరియు General Electric కలిసి Multics అనే ఆపరేటింగ్ సిస్టమ్ ప్రాజెక్ట్ ప్రారంభించాయి. అయితే ఆ ప్రాజెక్ట్ అత్యంత సంక్లిష్టంగా మారి విఫలమైంది. దాంతో బెల్ ల్యాబ్స్ ఇంజనీర్ అయిన Ken Thompson, ఒక చిన్న పాత కంప్యూటర్‌పై (PDP-7) సరళమైన ఆపరేటింగ్ సిస్టమ్‌ను నిర్మించాలని నిర్ణయించుకున్నాడు. ఆ సిస్టమ్ కోసం ఆయన B language (BCPL ఆధారంగా) అనే భాషను రూపొందించారు.
కానీ B లాంగ్వేజ్ కేవలం "Typeless" (అంటే డేటా టైప్స్ ఉండవు, ప్రతిదీ ఒక మెషిన్ వర్డ్ మాత్రమే) కావడం వల్ల సంక్లిష్టమైన మెమరీ మేనేజ్‌మెంట్ మరియు హార్డ్‌వేర్ కంట్రోల్ సాధ్యం కాలేదు. ఈ లోపాన్ని గుర్తించిన Dennis Ritchie, 1972 లో B లాంగ్వేజ్‌ను అభివృద్ధి చేస్తూ డేటా టైప్స్, స్ట్రక్చర్స్, మరియు పాయింటర్ల సామర్థ్యాలను జోడించి దానికి "C" అని పేరు పెట్టారు.
1973 లో డెన్నిస్ రిట్చీ మరియు కెన్ థాంప్సన్ కలిసి యావత్ UNIX Operating System కర్నల్ మొత్తాన్ని C భాషలోనే తిరిగి రాశారు. అంతవరకు ప్రపంచంలో ఏ ఆపరేటింగ్ సిస్టమ్ కూడా హై-లెవల్ లాంగ్వేజ్‌లో రాయబడలేదు (అన్నీ అసెంబ్లీలోనే రాసేవారు). ఈ సాహసోపేత నిర్ణయం సాఫ్ట్‌వేర్ రంగంలో అత్యంత పెద్ద మలుపుగా నిలిచింది!
| మైలురాయి (Year) | పరిణామం (Standard / Event) | కీలక విశేషం |
|---|---|---|
| 1972 | C పుట్టుక (Dennis Ritchie at Bell Labs) | UNIX కర్నల్ నిర్మాణానికి పునాది పడింది. |
| 1978 | K&R C (Brian Kernighan & Dennis Ritchie) | "The C Programming Language" బైబిల్ లాంటి పుస్తకం వెలువడింది. |
| 1989 (C89 / ANSI C) | ANSI ప్రమాణీకరణ (American National Standards) | ఫంక్షన్ ప్రొటోటైప్స్, వాయిడ్ పాయింటర్స్ అధికారికం అయ్యాయి. |
| 1999 (C99) | ISO/IEC 9899:1999 | inline ఫంక్షన్స్, // సింగిల్ లైన్ కామెంట్స్, <stdint.h>, వేరియబుల్ డిక్లరేషన్ ఎక్కడైనా అనుమతి. |
| 2011 (C11) & 2017 (C17) | ఆధునిక C ప్రమాణాలు | మల్టీ-త్రెడింగ్ సపోర్ట్ (<threads.h>), అటామిక్ ఆపరేషన్స్ (<stdatomic.h>), సెక్యూరిటీ బగ్ ఫిక్సెస్. |
పైథాన్, జావా వంటి ఆధునిక భాషలు వేలకొద్దీ ఉన్నప్పటికీ — నేటికీ గూగుల్, మైక్రోసాఫ్ట్, నాసా, టెస్లా మరియు ఆపిల్ కంపెనీలు తమ అత్యంత కీలకమైన సాఫ్ట్‌వేర్‌లను C లోనే ఎందుకు రాస్తాయి? దీనికి C లోని 4 అద్వితీయమైన ఫీచర్లు కారణం:
1. డైరెక్ట్ మెమరీ యాక్సెస్ (Pointers & RAM Addresses):
జావా లేదా పైథాన్‌లో కంప్యూటర్ మెమరీని నేరుగా తాకలేరు; వర్చువల్ మెషిన్ మధ్యలో అడ్డుగోడగా ఉంటుంది. కానీ C లో పాయింటర్లు (Pointers) ద్వారా కంప్యూటర్ RAM లోని ప్రతి బైట్ అడ్రస్‌ను డెవలపర్ నేరుగా రీడ్ చేయవచ్చు, మోడిఫై చేయవచ్చు. హార్డ్‌వేర్ రిజిస్టర్లతో నేరుగా మాట్లాడే శక్తి C కి మాత్రమే ఉంది.
2. జీరో రన్‌టైమ్ ఓవర్‌హెడ్ (Zero Runtime Overhead):
C కి ఎటువంటి గార్బేజ్ కలెక్టర్ (Garbage Collector) లేదా భారీ వర్చువల్ మెషిన్ (JVM లాంటివి) ఉండదు. మీ C కోడ్ కంపైలర్ ద్వారా నేరుగా ప్రాసెసర్ ఎగ్జిక్యూట్ చేయగల ప్యూర్ మెషిన్ కోడ్ (0s & 1s) గా మారుతుంది. దీనివల్ల C కోడ్ కాంతి వేగంతో నడుస్తుంది.
3. అత్యున్నత పోర్టబిలిటీ (Architecture Portability):
మీ చేతిలోని స్మార్ట్‌వాచ్ (ARM Cortex), వాషింగ్ మెషీన్ మైక్రోకంట్రోలర్, లేదా ప్రపంచంలోనే అత్యంత శక్తివంతమైన సూపర్ కంప్యూటర్ — ప్రతి ఎలక్ట్రానిక్ చిప్‌కు C కంపైలర్ అందుబాటులో ఉంటుంది. ఒకసారి రాసిన C లాజిక్‌ను కొద్దిపాటి మార్పులతో ఏ డివైస్‌కైనా కంపైల్ చేయవచ్చు.
4. డిటర్మినిస్టిక్ పెర్ఫార్మెన్స్ (Deterministic Predictability):
జావా లేదా పైథాన్‌లో గార్బేజ్ కలెక్టర్ ఎప్పుడు ఆన్ అవుతుందో, ఎప్పుడు ప్రోగ్రామ్ కొన్ని మిల్లీసెకన్లు ఫ్రీజ్ అవుతుందో మనం ఖచ్చితంగా చెప్పలేం. కానీ రాకెట్ లాంచ్‌లు, పేస్‌మేకర్‌లు, ఆటోమొబైల్ బ్రేకింగ్ సిస్టమ్స్ వంటి రియల్-టైమ్ సిస్టమ్స్‌లో ప్రతి మైక్రోసెకండ్ ముఖ్యం. C లో ఏ ఆపరేషన్ ఎన్ని సైకిల్స్ తీసుకుంటుందో డెవలపర్ నియంత్రణలోనే ఉంటుంది!
చాలామంది విద్యార్థులు కోడ్ రాసి ఒక బటన్ క్లిక్ చేయగానే నేరుగా అవుట్‌పుట్ వచ్చేస్తుందని అనుకుంటారు. కానీ తెరవెనుక GCC (GNU Compiler Collection) మీ సోర్స్ కోడ్‌ను నాలుగు ప్రాథమిక దశల ద్వారా మెషిన్ లాంగ్వేజ్‌గా మారుస్తుంది. ఈ పైప్‌లైన్‌ను స్పష్టంగా అర్థం చేసుకోవడం ఒక సిస్టమ్స్ ప్రోగ్రామర్‌కు తప్పనిసరి:
| దశ (Stage) | టూల్ (Tool) | కమాండ్ & ఇన్‌పుట్/అవుట్‌పుట్ | వాస్తవంగా ఏం జరుగుతుంది? |
|---|---|---|---|
| 1. Preprocessing | cpp (C Preprocessor) |
gcc -E hello.c -o hello.ihello.c → hello.i |
కామెంట్లు తొలగిస్తుంది, #include ఫైల్స్‌ను ఎంబెడ్ చేస్తుంది, #define మ్యాక్రోలను విస్తరిస్తుంది. |
| 2. Compilation | cc1 (C Compiler) |
gcc -S hello.i -o hello.shello.i → hello.s |
C గ్రామర్ మరియు సింటాక్స్ చెక్ చేసి, ప్రాసెసర్ అర్థం చేసుకోగల అసెంబ్లీ లాంగ్వేజ్ (.s) గా మారుస్తుంది. |
| 3. Assembly | as (Assembler) |
gcc -c hello.s -o hello.ohello.s → hello.o |
అసెంబ్లీ ఇన్‌స్ట్రక్షన్లను CPU చదవగల బైనరీ ఆబ్జెక్ట్ కోడ్ (Machine Code 0s & 1s) గా మారుస్తుంది. |
| 4. Linking | ld (Linker) |
gcc hello.o -o hello.exehello.o + libc → hello.exe |
మీ ఆబ్జెక్ట్ ఫైల్‌ను C స్టాండర్డ్ లైబ్రరీ ఫంక్షన్లతో (printf మొదలైనవి) అనుసంధానించి ఫైనల్ ఎగ్జిక్యూటబుల్ ఫైల్‌ను ఉత్పత్తి చేస్తుంది. |
gcc hello.c -o hello అని ఒక్క కమాండ్ ఇస్తాం. అప్పుడు GCC ఈ నాలుగు దశలను స్వయంచాలకంగా ఒకదాని తర్వాత ఒకటి పూర్తి చేసి తుది ఎగ్జిక్యూటబుల్ ఫైల్‌ను సిద్ధం చేస్తుంది.
ప్రపంచవ్యాప్తంగా ప్రతి ప్రోగ్రామర్ తన ప్రయాణాన్ని ప్రారంభించే సాంప్రదాయ ప్రోగ్రామ్ "Hello, World!". ఆధునిక C ప్రమాణాలకు అనుగుణంగా ఉన్న స్వచ్ఛమైన కోడ్ ఇది:
#include <stdio.h>
// ప్రోగ్రామ్ యొక్క ప్రధాన ప్రవేశ ద్వారం
int main(void) {
// కన్సోల్ స్క్రీన్‌పై సందేశాన్ని ముద్రించడం
printf("నమస్కారం, C ప్రోగ్రామింగ్ ప్రపంచానికి స్వాగతం!
");
// ఆపరేటింగ్ సిస్టమ్‌కు సక్సెస్ సిగ్నల్ పంపడం
return 0;
}ఈ 7 లైన్ల చిన్న ప్రోగ్రామ్‌లో ప్రతి అక్షరానికీ కంప్యూటర్ ఆర్కిటెక్చర్‌లో ఒక స్పష్టమైన, లోతైన బాధ్యత ఉంది. వాటిని తర్వాతి సెక్షన్లలో విడమరిచి చూద్దాం!
కోడ్‌లోని మొట్టమొదటి లైన్: #include <stdio.h>. దీనిని విడగొట్టి చూస్తే:
#(Hash / Pound): హాష్ గుర్తుతో మొదలయ్యే ప్రతి లైన్ Preprocessor Directive. అంటే అసలు కంపైలర్ కోడ్‌ను చూడకముందే "ప్రీప్రాసెసర్" అనే టూల్ ఈ లైన్‌ను ప్రాసెస్ చేస్తుంది.include: బాహ్య ఫైల్‌లోని కంటెంట్‌ను తీసుకొచ్చి ఈ కోడ్‌లో సరిగ్గా ఇక్కడే కాపీ చేసి పేస్ట్ చేయమని ఇచ్చే ఆదేశం.stdio.h: Standard Input Output Header ఫైల్. ఇందులో స్క్రీన్‌పై టెక్స్ట్ ప్రింట్ చేసేprintf(), కీబోర్డ్ నుండి ఇన్‌పుట్ తీసుకునేscanf()వంటి ఫంక్షన్ల యొక్క డిక్లరేషన్లు (Function Signatures) ఉంటాయి.< >(Angle Brackets): ఈ హెడర్ ఫైల్ సిస్టమ్ యొక్క స్టాండర్డ్ లైబ్రరీ ఫోల్డర్‌లో (ఉదా: Linux లో/usr/include/) ఉందని కంపైలర్‌కు చెబుతుంది. మన సొంత హెడర్ ఫైల్స్ అయితే డబుల్ కోట్స్#include "myheader.h"లో పెడతాం.
gcc -E hello.c రన్ చేసి చూస్తే — మీ 7 లైన్ల కోడ్ దాదాపు 800+ లైన్ల కోడ్‌గా మారిపోతుంది! ఎందుకంటే stdio.h లో ఉన్న అన్ని టైప్ డిఫినిషన్లు, మ్యాక్రోలు మీ ఫైల్‌లోకి ఆటోమేటిక్‌గా ఇంజెక్ట్ అవుతాయి.
ఒక C ప్రోగ్రామ్‌లో వేల సంఖ్యలో ఫంక్షన్లు ఉండవచ్చు. కానీ ఆపరేటింగ్ సిస్టమ్ ప్రోగ్రామ్‌ను రన్ చేయడానికి కేవలం ఒకే ఒక ప్రత్యేక పేరు గల ఫంక్షన్ కోసం వెతుకుతుంది — అదే main()!
int main(void) అనాటమీ:
- int (Return Type): ఈ ఫంక్షన్ తన పని ముగించుకున్నాక ఆపరేటింగ్ సిస్టమ్‌కు ఒక పూర్ణాంక సంఖ్యను (Integer Exit Code) బహుమతిగా తిరిగి ఇస్తుందని కంపైలర్‌కు ప్రకటిస్తుంది.
- main: ప్రోగ్రామ్ యొక్క ఎగ్జిక్యూషన్ ప్రారంభమయ్యే అధికారిక ఎంట్రీ పాయింట్ (Entry Point). ఈ పేరును మార్చకూడదు.
- void (Parameter List): ఈ ఫంక్షన్ ఎటువంటి ఇన్‌పుట్ పారామీటర్లను ఆశించడం లేదని స్పష్టంగా తెలియజేస్తుంది. (కమాండ్ లైన్ ఆర్గ్యుమెంట్లు అవసరమైనప్పుడు
int main(int argc, char *argv[])వాడతాం). - { } (Curly Braces): మెయిన్ ఫంక్షన్ యొక్క పరిధిని (Scope / Body) సూచిస్తాయి. ప్రోగ్రామ్ ఎగ్జిక్యూషన్ ఓపెనింగ్ బ్రేస్
{వద్ద మొదలై క్లోజింగ్ బ్రేస్}వద్ద ముగుస్తుంది.
printf అనేది C లో ప్రింట్ చేయడానికి ఉపయోగించే ఫంక్షన్. printf అంటే Print Formatted అని అర్థం. ఇది సాధారణ ప్రింట్ స్టేట్‌మెంట్ మాత్రమే కాదు; వేరియబుల్స్, నంబర్లు, క్యారెక్టర్లను ఒక ఫార్మాట్ ప్రకారం కన్సోల్ స్క్రీన్‌పై ముద్రించే ఒక అధునాతన ఫంక్షన్.
ముఖ్యమైన ఎస్కేప్ సీక్వెన్సెస్ (Escape Sequences):
టెక్స్ట్ ముద్రించేటప్పుడు కర్సర్‌ను నియంత్రించడానికి బ్యాక్‌స్లాష్ \ తో మొదలయ్యే ప్రత్యేక గుర్తులను ఉపయోగిస్తాం:
| ఎస్కేప్ సీక్వెన్స్ | పేరు | పనితీరు (Action) | ఉదాహరణ కోడ్ & ఫలితం |
|---|---|---|---|
\n |
Newline | కర్సర్‌ను వెంటనే తర్వాతి లైన్‌కు తీసుకెళ్తుంది. | printf("Hello\nWorld"); → రెండు లైన్లలో వస్తుంది. |
\t |
Horizontal Tab | కర్సర్‌ను 4 లేదా 8 స్పేస్‌ల దూరం ముందుకు జరుపుతుంది (కాలమ్స్ కోసం). | printf("పేరు:\tరమేష్"); → పేరు: రమేష్ |
\\ |
Backslash | స్క్రీన్‌పై ఒక బ్యాక్‌స్లాష్ గుర్తును ప్రింట్ చేస్తుంది. | printf("C:\\tc\\bin"); → C:\tc\bin |
\" |
Double Quote | స్ట్రింగ్ లోపల కొటేషన్ మార్క్‌ను ముద్రిస్తుంది. | printf("అతను \"హాయ్\" అన్నాడు"); → అతను "హాయ్" అన్నాడు |
\a |
Alert (Bell) | కంప్యూటర్ స్పీకర్ నుండి చిన్న బీప్ శబ్దం వినిపిస్తుంది. | printf("\aహెచ్చరిక!"); |
.) ఎలా పెడతామో — C లాంగ్వేజ్‌లో ప్రతి ఎగ్జిక్యూటబుల్ స్టేట్‌మెంట్ ముగింపులో సెమికోలన్ (;) తప్పనిసరి. సెమికోలన్ లేకపోతే కంపైలర్ error: expected ';' before token అని గగ్గోలు పెడుతుంది!
చాలామంది ప్రోగ్రామర్లు return 0; అనేది ఒక సాంప్రదాయ లైన్ మాత్రమే అనుకుంటారు. కానీ ఆపరేటింగ్ సిస్టమ్ దృక్కోణంలో ఇది అత్యంత కీలకమైన లైన్!
ఒక C ప్రోగ్రామ్ రన్ అవుతున్నప్పుడు, దానిని ఆపరేటింగ్ సిస్టమ్ యొక్క షెల్ (Bash లేదా Windows CMD) ఒక చైల్డ్ ప్రాసెస్ (Child Process) గా నడుపుతుంది. ప్రోగ్రామ్ పని పూర్తయిన తర్వాత తన పేరెంట్ ప్రాసెస్‌కు ఒక నివేదికను (Exit Code) అందజేయాలి:
return 0;: సక్సెస్ (Success) కోడ్! ప్రోగ్రామ్ ఎలాంటి లోపాలు లేకుండా, సురక్షితంగా తన లక్ష్యాన్ని పూర్తి చేసిందని ఆపరేటింగ్ సిస్టమ్‌కు తెలియజేస్తుంది.return 1;(లేదా సున్నా కాని ఏదైనా సంఖ్య) : వైఫల్యం (Failure / Error)! ఫైల్ దొరకకపోవడం, నెట్‌వర్క్ ఫెయిల్ అవ్వడం లేదా మెమరీ లోపం వల్ల ప్రోగ్రామ్ మధ్యలోనే ఆగిపోయిందని సూచిస్తుంది.
లైనక్స్ టెర్మినల్‌లో ప్రోగ్రామ్ రన్ అయ్యాక echo $? అని టైప్ చేస్తే — మీ ప్రోగ్రామ్ రిటర్న్ చేసిన ఆ సంఖ్య (0) స్క్రీన్ మీద కనిపిస్తుంది!
భారతదేశంలోని అనేక ఇంజనీరింగ్ కాలేజీలలో పాత సిలబస్‌ను అనుసరిస్తూ ఇప్పటికీ ప్రొఫెసర్లు బోర్డు మీద void main() అని రాస్తుంటారు. కానీ ప్రపంచ ఇంటర్వ్యూలలో లేదా గూగుల్/మైక్రోసాఫ్ట్ వంటి టాప్ కంపెనీల కోడింగ్ టెస్టులలో void main() రాస్తే అది తప్పుడు కోడ్‌గా పరిగణించబడుతుంది!
| అంశం (Factor) | void main() (పాత పద్ధతి) | int main(void) (ఆధునిక ప్రమాణం) |
|---|---|---|
| C స్టాండర్డ్ కంప్లైయన్స్ | ❌ C99, C11, C17, C23 ప్రమాణాలలో అనుమతించబడదు (Non-Standard). | ✅ అధికారిక అంతర్జాతీయ C ప్రమాణాల ప్రకారం 100% సరైనది. |
| OS Exit Status | ఆపరేటింగ్ సిస్టమ్‌కు ఎగ్జిట్ స్టేటస్ వెళ్ళదు (గార్బేజ్ విలువ వెళ్తుంది). | ఆపరేటింగ్ సిస్టమ్‌కు స్పష్టమైన ఎగ్జిట్ కోడ్ (0) అందుతుంది. |
| కంపైలర్ బిహేవియర్ | ఆధునిక GCC / Clang కంపైలర్లలో warning: return type of 'main' is not 'int' వస్తుంది. |
జీరో వార్నింగ్స్, క్లీన్ కంపైలేషన్. |
| ఉపయోగించబడిన సందర్భం | 1990ల నాటి పాత Turbo C++ DOS ఎమ్యులేటర్. | ఆధునిక Linux, Windows 11, macOS, 64-bit GCC/Clang. |
void main() రాయకండి; ఎల్లప్పుడూ int main(void) లేదా int main() మాత్రమే రాయండి!
C నేర్చుకునే ప్రారంభ రోజుల్లో విద్యార్థులు చేసే సాధారణ తప్పులను ముందుగానే తెలుసుకుంటే గంటల తరబడి డీబగ్గింగ్ తలనొప్పి తప్పుతుంది:
#include <stdio.h>; // తప్పు! Preprocessor డైరెక్టివ్‌లకు సెమికోలన్ ఉండదు!#include మరియు #define చివర సెమికోలన్ పెట్టకూడదు.
Printf("Hello World"); // తప్పు! C లో 'P' క్యాపిటల్ ఉండకూడదుint, return, printf) చిన్న అక్షరాలలో (Lowercase) మాత్రమే ఉండాలి.
printf('Hello World
'); // తప్పు! సింగిల్ కోట్స్ స్ట్రింగ్స్ కోసం కాదు!"..." లోనే ఉండాలి. సింగిల్ కోట్స్ '...' కేవలం ఒకే ఒక్క క్యారెక్టర్ (ఉదా: 'A', '9') కోసం మాత్రమే వాడాలి.
int main(); { // తప్పు! ఫంక్షన్ డెఫినిషన్ హెడర్ చివర సెమికోలన్ ఉండకూడదు!{ } రావాలి. అక్కడ సెమికోలన్ పెడితే కంపైలర్ అది ఫంక్షన్ డిక్లరేషన్‌గా భావించి లోపలి కోడ్‌ను గుర్తించలేదు.
ఈ మొదటి అధ్యాయంలో మీరు నేర్చుకున్న భావనలను పరీక్షించుకోవడానికి క్రింది ప్రశ్నలపై క్లిక్ చేసి సరైన సమాధానాలను పరిశీలించండి:
❓ ప్రశ్న 1: GCC కంపైలేషన్ పైప్‌లైన్‌లో సోర్స్ కోడ్ నుండి కామెంట్లు తొలగించి, హెడర్ ఫైల్స్ ఇన్సర్ట్ చేసే దశ ఏది?
cpp) కామెంట్లను తొలగించి, #include డైరెక్టివ్‌ల స్థానంలో వాస్తవ హెడర్ ఫైల్ కోడ్‌ను పేస్ట్ చేస్తుంది.
❓ ప్రశ్న 2: అసెంబ్లర్ ఉత్పత్తి చేసే ఫైల్ ఫార్మాట్ ఏది?
❓ ప్రశ్న 3: main() ఫంక్షన్ చివర return 0; ఎందుకు రాస్తాం?
❓ ప్రశ్న 4: stdio.h ఫైల్ పేరులోని 'stdio' యొక్క పూర్తి రూపం ఏమిటి?
❓ ప్రశ్న 5: ఆధునిక C ప్రమాణాల ప్రకారం void main() ఎందుకు తప్పు?
main ఫంక్షన్ ఎల్లప్పుడూ ఆపరేటింగ్ సిస్టమ్‌కు ఒక పూర్ణాంక సంఖ్యను (int exit status) రిటర్న్ చేయాలి. void main() అనేది చెల్లని నాన్-స్టాండర్డ్ సింటాక్స్ (Undefined Behavior).
పైన వివరించిన Hello, World! కోడ్‌ను మన ఆన్‌లైన్ GCC C కంపైలర్‌లో ఓపెన్ చేసి స్వయంగా ఎగ్జిక్యూట్ చేయండి. ప్రింట్ సందేశంలో మీ పేరును చేర్చి రన్ చేసి నిజమైన కంపైలర్ అనుభూతిని పొందండి!
📌 క్విక్ సారాంశం (Key Takeaways):
- C మూలాలు: 1972 లో Dennis Ritchie బెల్ ల్యాబ్స్‌లో UNIX ఆపరేటింగ్ సిస్టమ్ కోసం రూపొందించారు.
- 4 GCC దశలు: Preprocessing (.i) → Compilation (.s) → Assembly (.o) → Linking (.exe).
- ఎంట్రీ పాయింట్: ఎగ్జిక్యూషన్ ఎల్లప్పుడూ
int main(void)వద్దే ప్రారంభమవుతుంది. - stdio.h: ప్రింట్ మరియు ఇన్‌పుట్ ఫంక్షన్ల కోసం Standard I/O హెడర్ ఫైల్.
- return 0: OS కి ప్రోగ్రామ్ సురక్షితంగా విజయవంతమైందని తెలిపే సంకేతం.