"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { blockquote: "blockquote", code: "code", h3: "h3", li: "li", p: "p", pre: "pre", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview} = _components; if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!ContentAttribution) _missingMdxReference("ContentAttribution", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "4.2", title: "Library Functions" }), _jsxs(TopicOverview, { title: "Library Functions in C", topicId: "4.2", readingTime: "9 min read", difficulty: "Medium", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["C programming provides a rich set of pre-built functions organized into standard header files. These ", _jsx(_components.strong, { children: "library functions" }), " save developers from writing common functionality from scratch. Whether you need to calculate square roots, manipulate strings, read characters, or allocate memory dynamically — C has ready-made functions for all of these tasks. In this section, we explore three major categories: ", _jsx(_components.strong, { children: "Math functions" }), " from ", _jsx(_components.code, { children: "math.h" }), ", ", _jsx(_components.strong, { children: "String handling functions" }), " from ", _jsx(_components.code, { children: "string.h" }), ", and ", _jsx(_components.strong, { children: "miscellaneous functions" }), " like ", _jsx(_components.code, { children: "getchar()" }), ", ", _jsx(_components.code, { children: "putchar()" }), ", ", _jsx(_components.code, { children: "malloc()" }), ", and ", _jsx(_components.code, { children: "calloc()" }), "."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["C programming mein bahut saare pre-built functions hote hain jo different header files mein organized hote hain. Inhe hum ", _jsx(_components.strong, { children: "library functions" }), " kehte hain. Agar humein square root nikalna ho, strings manipulate karni ho, characters read karna ho, ya memory dynamically allocate karni ho — C mein sab ke liye ready-made functions available hain. Is section mein hum teen major categories dekhenge: ", _jsx(_components.strong, { children: "Math functions" }), " jo ", _jsx(_components.code, { children: "math.h" }), " mein hoti hain, ", _jsx(_components.strong, { children: "String handling functions" }), " jo ", _jsx(_components.code, { children: "string.h" }), " mein hoti hain, aur kuch ", _jsx(_components.strong, { children: "miscellaneous functions" }), " jaise ", _jsx(_components.code, { children: "getchar()" }), ", ", _jsx(_components.code, { children: "putchar()" }), ", ", _jsx(_components.code, { children: "malloc()" }), ", aur ", _jsx(_components.code, { children: "calloc()" }), "."] }) })] }), _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Library Functions", children: [_jsx(English, { children: _jsx(_components.p, { children: "Pre-defined functions bundled with the C standard library, stored in header files. They provide commonly needed functionality — like mathematical calculations, string manipulation, and memory management — so programmers don't have to reinvent the wheel for every task." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Ye wo pre-defined functions hain jo C standard library ke saath aate hain aur header files mein stored hote hain. Ye commonly kaam aane wali functionality provide karte hain — jaise mathematical calculations, string manipulation, aur memory management — taaki programmers ko har kaam ke liye zero se function na likhna pade." }) })] }), _jsxs(DefinitionEntry, { term: "Math Functions", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A group of functions declared in the ", _jsx(_components.code, { children: "math.h" }), " header file that perform mathematical operations like square root, power, trigonometric calculations, rounding, and logarithmic computations on floating-point numbers."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Ye functions ", _jsx(_components.code, { children: "math.h" }), " header file mein declare kiye jaate hain aur mathematical operations perform karte hain — jaise square root nikalna, power calculate karna, trigonometric calculations, rounding, aur logarithmic computations. Ye sab floating-point numbers par kaam karte hain."] }) })] }), _jsxs(DefinitionEntry, { term: "String Handling Functions", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A collection of functions from the ", _jsx(_components.code, { children: "string.h" }), " header file designed to perform operations on character arrays (strings) — such as finding length, copying, concatenating, comparing, and searching within strings."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Ye functions ", _jsx(_components.code, { children: "string.h" }), " header file se aate hain aur character arrays (strings) par operations perform karte hain — jaise length nikalna, copy karna, concatenate karna, compare karna, aur strings mein search karna."] }) })] }), _jsxs(DefinitionEntry, { term: "Dynamic Memory Allocation", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The process of allocating memory at runtime using functions like ", _jsx(_components.code, { children: "malloc()" }), " and ", _jsx(_components.code, { children: "calloc()" }), " from ", _jsx(_components.code, { children: "stdlib.h" }), ", as opposed to compile-time allocation. This allows programs to request memory based on actual needs during execution."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Ye process hai jismein hum runtime par memory allocate karte hain ", _jsx(_components.code, { children: "malloc()" }), " aur ", _jsx(_components.code, { children: "calloc()" }), " functions ka use karke, jo ", _jsx(_components.code, { children: "stdlib.h" }), " mein hote hain. Isse programs execution ke dauran actual zaroorat ke hisaab se memory maang sakte hain, jo compile-time allocation se alag hai."] }) })] }), _jsxs(DefinitionEntry, { term: "getchar() and putchar()", children: [_jsx(English, { children: _jsxs(_components.p, { children: [_jsx(_components.code, { children: "getchar()" }), " is a function from ", _jsx(_components.code, { children: "stdio.h" }), " that reads a single character from the standard input (keyboard), while ", _jsx(_components.code, { children: "putchar()" }), " writes a single character to the standard output (screen). They are the simplest form of character-level input/output in C."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.code, { children: "getchar()" }), " ek function hai ", _jsx(_components.code, { children: "stdio.h" }), " se jo standard input (keyboard) se ek single character read karta hai, aur ", _jsx(_components.code, { children: "putchar()" }), " standard output (screen) par ek single character write karta hai. Ye C mein character-level input/output ka sabse simple form hain."] }) })] })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "📚 Why Use Library Functions?" }), _jsxs(_components.p, { children: ["Imagine you are building a house. You don't manufacture bricks and cement from scratch — you buy them ready-made from a shop and use them directly. ", _jsx(_components.strong, { children: "Library functions work exactly the same way in C programming." }), " Instead of writing code for common tasks from scratch, you simply include the right header file and call the pre-built function."] }), _jsx(_components.p, { children: "This approach has three major benefits:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Saves time" }), " — no need to write complex algorithms for standard operations"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Reduces errors" }), " — library functions are tested and debugged by thousands of developers"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Improves readability" }), " — using ", _jsx(_components.code, { children: "sqrt(x)" }), " is much clearer than writing your own square root algorithm"] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📚 Why Library Functions Use Karte Hain?" }), _jsxs(_components.p, { children: ["Sochiye aap ek ghar bana rahe hain. Aap eent, cement zero se nahi bana rahe — ready-made shop se kharidte hain aur directly use karte hain. ", _jsx(_components.strong, { children: "C programming mein library functions bilkul isi tarah kaam karte hain." }), " Common tasks ke liye code zero se likhne ki bajaye, aap simply sahi header file include karte hain aur pre-built function call kar dete hain."] }), _jsx(_components.p, { children: "Iske teen bade fayde hain:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Time bachta hai" }), " — standard operations ke liye complex algorithms likhne ki zaroorat nahi"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Errors kam hote hain" }), " — library functions bahut achhe se test aur debug kiye jaate hain"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Code readable hota hai" }), " — ", _jsx(_components.code, { children: "sqrt(x)" }), " likhna custom algorithm likhne se kahi zyada clear hai"] }), "\n"] })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\n A[\"C Library Functions\"] --> B[\"Math Functions (math.h)\"]\n A --> C[\"String Functions (string.h)\"]\n A --> D[\"Character I/O (stdio.h)\"]\n A --> E[\"Dynamic Memory (stdlib.h)\"]\n B --> B1[\"sqrt, pow, ceil, floor\"]\n C --> C1[\"strlen, strcpy, strcmp\"]\n D --> D1[\"getchar, putchar, puts\"]\n E --> E1[\"malloc, calloc, free\"]\n" }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📐 Math Functions (math.h)" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "math.h" }), " header file provides functions for common mathematical operations. These functions work with ", _jsx(_components.strong, { children: "floating-point numbers" }), " (", _jsx(_components.code, { children: "float" }), " and ", _jsx(_components.code, { children: "double" }), " types). Here are the most commonly used math functions:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Basic Math:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "sqrt(x)" }), " — returns square root of x"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "pow(x, y)" }), " — returns x raised to the power y"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "abs(x)" }), " — returns absolute value of integer (note: this is from ", _jsx(_components.code, { children: "stdlib.h" }), ", not ", _jsx(_components.code, { children: "math.h" }), ")"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Rounding Functions:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ceil(x)" }), " — rounds x ", _jsx(_components.strong, { children: "up" }), " to the nearest integer (e.g. ", _jsx(_components.code, { children: "ceil(2.3)" }), " gives 3)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "floor(x)" }), " — rounds x ", _jsx(_components.strong, { children: "down" }), " to the nearest integer (e.g. ", _jsx(_components.code, { children: "floor(2.7)" }), " gives 2)"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Floating-Point Math:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "fabs(x)" }), " — returns absolute value of a float/double"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "fmod(x, y)" }), " — returns the floating-point remainder when x is divided by y"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Logarithmic Functions:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "log(x)" }), " — returns natural logarithm (base e) of x"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "log10(x)" }), " — returns base-10 logarithm of x"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Trigonometric Functions:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "sin(x)" }), " — returns sine of x (x must be in radians)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "cos(x)" }), " — returns cosine of x"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "tan(x)" }), " — returns tangent of x"] }), "\n"] }), _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["⚠️ ", _jsx(_components.strong, { children: "Important:" }), " On Linux/GCC compilers, you may need to add ", _jsx(_components.code, { children: "-lm" }), " flag while compiling (e.g., ", _jsx(_components.code, { children: "gcc program.c -o program -lm" }), ") to link the math library."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📐 Math Functions (math.h)" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "math.h" }), " header file mein mathematical operations ke liye functions hote hain. Ye functions ", _jsx(_components.strong, { children: "floating-point numbers" }), " (", _jsx(_components.code, { children: "float" }), " aur ", _jsx(_components.code, { children: "double" }), " types) ke saath kaam karte hain. Ye hain sabse zyada use hone wale math functions:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Basic Math:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "sqrt(x)" }), " — x ka square root return karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "pow(x, y)" }), " — x ki y power return karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "abs(x)" }), " — integer ka absolute value return karta hai (note: ye ", _jsx(_components.code, { children: "stdlib.h" }), " se aata hai, ", _jsx(_components.code, { children: "math.h" }), " se nahi)"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Rounding Functions:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "ceil(x)" }), " — x ko ", _jsx(_components.strong, { children: "upar" }), " round karta hai nearest integer tak (jaise ", _jsx(_components.code, { children: "ceil(2.3)" }), " deta hai 3)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "floor(x)" }), " — x ko ", _jsx(_components.strong, { children: "neeche" }), " round karta hai nearest integer tak (jaise ", _jsx(_components.code, { children: "floor(2.7)" }), " deta hai 2)"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Floating-Point Math:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "fabs(x)" }), " — float/double ka absolute value return karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "fmod(x, y)" }), " — x ko y se divide karne par floating-point remainder return karta hai"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Logarithmic Functions:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "log(x)" }), " — natural logarithm (base e) return karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "log10(x)" }), " — base-10 logarithm return karta hai"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Trigonometric Functions:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "sin(x)" }), " — x ka sine return karta hai (x radians mein hona chahiye)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "cos(x)" }), " — x ka cosine return karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "tan(x)" }), " — x ka tangent return karta hai"] }), "\n"] }), _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["⚠️ ", _jsx(_components.strong, { children: "Important:" }), " Linux/GCC compilers par compile karte waqt ", _jsx(_components.code, { children: "-lm" }), " flag lagana padta hai (jaise ", _jsx(_components.code, { children: "gcc program.c -o program -lm" }), ") taaki math library properly link ho."] }), "\n"] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include #include int main() { double x = 25.0, y = 3.0; // Basic Math Functions printf("sqrt(%.1f) = %.2f\\n", x, sqrt(x)); // sqrt(25.0) = 5.00 printf("pow(%.1f, %.1f) = %.2f\\n", x, y, pow(x, y)); // pow(25.0, 3.0) = 15625.00 printf("abs(-10) = %d\\n", abs(-10)); // abs(-10) = 10 // Rounding Functions printf("ceil(4.3) = %.0f\\n", ceil(4.3)); // ceil(4.3) = 5 printf("floor(4.7) = %.0f\\n", floor(4.7)); // floor(4.7) = 4 // Floating-Point Math printf("fabs(-10.5) = %.2f\\n", fabs(-10.5)); // fabs(-10.5) = 10.50 printf("fmod(10.0, 3.0) = %.2f\\n", fmod(10.0, 3.0)); // fmod(10.0, 3.0) = 1.00 // Logarithmic Functions printf("log(2.718) = %.2f\\n", log(2.718)); // log(2.718) ≈ 1.00 printf("log10(100) = %.2f\\n", log10(100.0)); // log10(100) = 2.00 // Trigonometric Functions (input in radians) printf("sin(pi/2) = %.2f\\n", sin(3.14159 / 2)); // sin(pi/2) = 1.00 printf("cos(0) = %.2f\\n", cos(0.0)); // cos(0) = 1.00 printf("tan(pi/4) = %.2f\\n", tan(3.14159 / 4)); // tan(pi/4) = 1.00 return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 String Handling Functions (string.h)" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "string.h" }), " header file provides functions to work with ", _jsx(_components.strong, { children: "strings" }), " (character arrays terminated by the null character ", _jsx(_components.code, { children: "\\0" }), "). Here are the most important string functions:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Length and Copy:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strlen(str)" }), " — returns the number of characters in str (excluding the ", _jsx(_components.code, { children: "\\0" }), ")"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strcpy(dest, src)" }), " — copies the entire string from src to dest (including ", _jsx(_components.code, { children: "\\0" }), ")"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strncpy(dest, src, n)" }), " — copies at most n characters from src to dest"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Concatenation:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strcat(dest, src)" }), " — appends the string src to the end of dest"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strncat(dest, src, n)" }), " — appends at most n characters from src to dest"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Comparison:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strcmp(s1, s2)" }), " — compares two strings lexicographically; returns ", _jsx(_components.strong, { children: "0" }), " if equal, ", _jsx(_components.strong, { children: "negative" }), " if s1 comes before s2, ", _jsx(_components.strong, { children: "positive" }), " if s1 comes after s2"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strncmp(s1, s2, n)" }), " — compares at most n characters of the two strings"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Searching:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strchr(str, ch)" }), " — finds the ", _jsx(_components.strong, { children: "first" }), " occurrence of character ch in str; returns a pointer to it, or ", _jsx(_components.code, { children: "NULL" }), " if not found"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strrchr(str, ch)" }), " — finds the ", _jsx(_components.strong, { children: "last" }), " occurrence of character ch in str"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strstr(str1, str2)" }), " — finds the first occurrence of the substring str2 inside str1"] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 String Handling Functions (string.h)" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "string.h" }), " header file mein ", _jsx(_components.strong, { children: "strings" }), " (character arrays jo ", _jsx(_components.code, { children: "\\0" }), " se terminate hoti hain) par kaam karne ke liye functions hote hain. Ye hain sabse important string functions:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Length aur Copy:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strlen(str)" }), " — str mein kitne characters hain return karta hai (", _jsx(_components.code, { children: "\\0" }), " ko chhodkar)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strcpy(dest, src)" }), " — poora string src se dest mein copy karta hai (", _jsx(_components.code, { children: "\\0" }), " samet)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strncpy(dest, src, n)" }), " — src se maximum n characters dest mein copy karta hai"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Concatenation:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strcat(dest, src)" }), " — src string ko dest ke end mein jod deta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strncat(dest, src, n)" }), " — src se maximum n characters dest mein jod deta hai"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Comparison:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strcmp(s1, s2)" }), " — dono strings ko lexicographically compare karta hai; ", _jsx(_components.strong, { children: "0" }), " return karta hai agar equal hain, ", _jsx(_components.strong, { children: "negative" }), " agar s1 pehle aata hai, ", _jsx(_components.strong, { children: "positive" }), " agar s1 baad mein aata hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strncmp(s1, s2, n)" }), " — dono strings ke maximum n characters compare karta hai"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Searching:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strchr(str, ch)" }), " — str mein character ch ka ", _jsx(_components.strong, { children: "pehla" }), " occurrence dhundhta hai; uska pointer return karta hai, ya ", _jsx(_components.code, { children: "NULL" }), " agar nahi mila"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strrchr(str, ch)" }), " — str mein character ch ka ", _jsx(_components.strong, { children: "last" }), " occurrence dhundhta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "strstr(str1, str2)" }), " — str1 ke andar substring str2 ka pehla occurrence dhundhta hai"] }), "\n"] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include int main() { char str1[50] = "Hello"; char str2[] = "World"; char str3[50]; int result; // strlen - find length of string printf("Length of str1 = %lu\\n", strlen(str1)); // Length = 5 // strcpy - copy string strcpy(str3, str1); printf("After strcpy: str3 = %s\\n", str3); // str3 = Hello // strcat - concatenate strings strcat(str1, " "); strcat(str1, str2); printf("After strcat: str1 = %s\\n", str1); // str1 = Hello World // strcmp - compare two strings result = strcmp("apple", "banana"); if (result == 0) printf("Strings are equal\\n"); else if (result < 0) printf("apple comes before banana\\n"); // This prints else printf("apple comes after banana\\n"); // strchr - find first occurrence of a character char *ptr = strchr(str1, 'W'); if (ptr != NULL) printf("Found 'W' at index: %ld\\n", ptr - str1); // index: 6 // strstr - find substring within a string char *sub = strstr(str1, "World"); if (sub != NULL) printf("Substring found: %s\\n", sub); // Substring found: World return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "⌨️ Character and String I/O Functions (stdio.h)" }), _jsxs(_components.p, { children: ["These functions from ", _jsx(_components.code, { children: "stdio.h" }), " handle basic character and string input/output:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Character I/O:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "getchar()" }), " — reads a single character from standard input (keyboard) and returns it as an ", _jsx(_components.code, { children: "int" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "putchar(ch)" }), " — writes a single character ", _jsx(_components.code, { children: "ch" }), " to standard output (screen)"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "String I/O:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "puts(str)" }), " — writes a string to standard output followed by a newline character automatically"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "gets(str)" }), " — reads a string from standard input until a newline is encountered (⚠️ ", _jsx(_components.strong, { children: "deprecated" }), " in C11 — use ", _jsx(_components.code, { children: "fgets(str, size, stdin)" }), " instead for safety)"] }), "\n"] }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "getchar()" }), " and ", _jsx(_components.code, { children: "putchar()" }), " functions are particularly useful when you need to process input ", _jsx(_components.strong, { children: "character by character" }), " — for example, counting vowels, converting case, or skipping whitespace."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "⌨️ Character aur String I/O Functions (stdio.h)" }), _jsxs(_components.p, { children: ["Ye functions ", _jsx(_components.code, { children: "stdio.h" }), " se aate hain aur basic character aur string input/output handle karte hain:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Character I/O:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "getchar()" }), " — standard input (keyboard) se ek single character read karta hai aur ", _jsx(_components.code, { children: "int" }), " ke roop mein return karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "putchar(ch)" }), " — ek single character ", _jsx(_components.code, { children: "ch" }), " ko standard output (screen) par write karta hai"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "String I/O:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "puts(str)" }), " — standard output par string write karta hai aur automatically newline character bhi add karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "gets(str)" }), " — standard input se string read karta hai newline tak (⚠️ ", _jsx(_components.strong, { children: "deprecated" }), " hai C11 mein — safety ke liye ", _jsx(_components.code, { children: "fgets(str, size, stdin)" }), " use karo)"] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "getchar()" }), " aur ", _jsx(_components.code, { children: "putchar()" }), " functions tab bahut kaam aate hain jab humein input ", _jsx(_components.strong, { children: "character by character" }), " process karna ho — jaise vowels count karna, case convert karna, ya whitespace skip karna."] })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { char ch; char name[50]; // getchar - read a single character printf("Enter a character: "); ch = getchar(); // putchar - display that character printf("You entered: "); putchar(ch); putchar('\\n'); // Using getchar() in a loop to read characters printf("Enter your name: "); int i = 0; while ((ch = getchar()) != '\\n' && ch != EOF) { name[i++] = ch; } name[i] = '\\0'; // manually terminate the string // puts - display string with automatic newline printf("Hello, "); puts(name); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🧠 Dynamic Memory Functions (stdlib.h)" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "stdlib.h" }), " header file provides functions for ", _jsx(_components.strong, { children: "dynamic memory allocation" }), " — allocating memory at runtime instead of compile-time. This is essential when you don't know in advance how much memory your program will need."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "malloc(size)" }), " — allocates ", _jsx(_components.code, { children: "size" }), " bytes of ", _jsx(_components.strong, { children: "uninitialized" }), " memory and returns a ", _jsx(_components.code, { children: "void*" }), " pointer to the allocated block (or ", _jsx(_components.code, { children: "NULL" }), " if allocation fails)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "calloc(count, size)" }), " — allocates memory for ", _jsx(_components.code, { children: "count" }), " elements, each of ", _jsx(_components.code, { children: "size" }), " bytes, and ", _jsx(_components.strong, { children: "initializes all bytes to zero" }), "; returns a ", _jsx(_components.code, { children: "void*" }), " pointer"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "realloc(ptr, newsize)" }), " — resizes a previously allocated memory block to ", _jsx(_components.code, { children: "newsize" }), " bytes, preserving existing data"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "free(ptr)" }), " — deallocates (frees) the memory block previously allocated by ", _jsx(_components.code, { children: "malloc()" }), " or ", _jsx(_components.code, { children: "calloc()" })] }), "\n"] }), _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Critical:" }), " Always check if ", _jsx(_components.code, { children: "malloc()" }), " or ", _jsx(_components.code, { children: "calloc()" }), " returned ", _jsx(_components.code, { children: "NULL" }), " before using the pointer. Always call ", _jsx(_components.code, { children: "free()" }), " when you are done with dynamically allocated memory to prevent ", _jsx(_components.strong, { children: "memory leaks" }), "."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🧠 Dynamic Memory Functions (stdlib.h)" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "stdlib.h" }), " header file mein ", _jsx(_components.strong, { children: "dynamic memory allocation" }), " ke liye functions hote hain — ye runtime par memory allocate karte hain compile-time ki bajaye. Ye tab zaroori hota hai jab humein pehle se pata nahi hota ki humare program ko kitni memory chahiye."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "malloc(size)" }), " — ", _jsx(_components.code, { children: "size" }), " bytes ki ", _jsx(_components.strong, { children: "uninitialized" }), " memory allocate karta hai aur ", _jsx(_components.code, { children: "void*" }), " pointer return karta hai (ya ", _jsx(_components.code, { children: "NULL" }), " agar allocation fail ho)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "calloc(count, size)" }), " — ", _jsx(_components.code, { children: "count" }), " elements ke liye memory allocate karta hai, har element ", _jsx(_components.code, { children: "size" }), " bytes ka, aur ", _jsx(_components.strong, { children: "sab bytes ko zero se initialize" }), " karta hai; ", _jsx(_components.code, { children: "void*" }), " pointer return karta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "realloc(ptr, newsize)" }), " — pehle allocate ki gayi memory block ka size ", _jsx(_components.code, { children: "newsize" }), " bytes mein change karta hai, existing data preserve karte hue"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "free(ptr)" }), " — ", _jsx(_components.code, { children: "malloc()" }), " ya ", _jsx(_components.code, { children: "calloc()" }), " se pehle allocate ki gayi memory block ko deallocate (free) karta hai"] }), "\n"] }), _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["💡 ", _jsx(_components.strong, { children: "Critical:" }), " ", _jsx(_components.code, { children: "malloc()" }), " ya ", _jsx(_components.code, { children: "calloc()" }), " se pointer lene se pehle hamesha check karo ki wo ", _jsx(_components.code, { children: "NULL" }), " nahi hai. Dynamically allocated memory ka kaam ho jaane ke baad hamesha ", _jsx(_components.code, { children: "free()" }), " call karo taaki ", _jsx(_components.strong, { children: "memory leaks" }), " na hon."] }), "\n"] })] }), _jsx(ComparisonTable, { title: "malloc vs calloc — Key Differences", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Feature" }), _jsx(_components.th, { children: "malloc" }), _jsx(_components.th, { children: "calloc" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Arguments" }), _jsx(_components.td, { children: "Single argument: total bytes" }), _jsx(_components.td, { children: "Two arguments: count and size of each element" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Initialization" }), _jsx(_components.td, { children: "Does NOT initialize memory (contains garbage values)" }), _jsx(_components.td, { children: "Initializes all bytes to zero" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Syntax" }), _jsx(_components.td, { children: "ptr = (type *)malloc(size)" }), _jsx(_components.td, { children: "ptr = (type *)calloc(count, size)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Speed" }), _jsx(_components.td, { children: "Faster (no initialization overhead)" }), _jsx(_components.td, { children: "Slightly slower (performs zero-initialization)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Use case" }), _jsx(_components.td, { children: "When you will assign values immediately" }), _jsx(_components.td, { children: "When you need a clean zero-initialized block" })] })] })] }) }), _jsx(CodeBlock, { language: "c", children: `#include #include int main() { int n = 5, i; // --- malloc: allocate memory for 5 integers --- int *arr1 = (int *)malloc(n * sizeof(int)); // Always check if malloc succeeded if (arr1 == NULL) { printf("malloc failed!\\n"); return 1; } // Memory is UNINITIALIZED — contains garbage values printf("malloc (before assigning): "); for (i = 0; i < n; i++) printf("%d ", arr1[i]); printf("\\n"); // Assign values manually for (i = 0; i < n; i++) arr1[i] = (i + 1) * 10; printf("malloc (after assigning): "); for (i = 0; i < n; i++) printf("%d ", arr1[i]); printf("\\n"); // 10 20 30 40 50 free(arr1); // free the malloc'd memory // --- calloc: allocate and zero-initialize --- int *arr2 = (int *)calloc(n, sizeof(int)); if (arr2 == NULL) { printf("calloc failed!\\n"); return 1; } // Memory is ZERO-INITIALIZED printf("calloc (auto zero-init): "); for (i = 0; i < n; i++) printf("%d ", arr2[i]); printf("\\n"); // 0 0 0 0 0 // --- realloc: resize the block from 5 to 8 integers --- arr2 = (int *)realloc(arr2, 8 * sizeof(int)); if (arr2 == NULL) { printf("realloc failed!\\n"); return 1; } printf("after realloc (8 ints): "); for (i = 0; i < 8; i++) printf("%d ", arr2[i]); printf("\\n"); // 0 0 0 0 0 0 0 0 free(arr2); // free the realloc'd memory return 0; }` }), _jsx(Remember, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Always include the correct header file" }), " before using library functions: ", _jsx(_components.code, { children: "math.h" }), " for math, ", _jsx(_components.code, { children: "string.h" }), " for strings, ", _jsx(_components.code, { children: "stdlib.h" }), " for memory allocation, ", _jsx(_components.code, { children: "stdio.h" }), " for character I/O"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Link ", _jsx(_components.code, { children: "-lm" }), " flag"] }), " on GCC/Linux when using ", _jsx(_components.code, { children: "math.h" }), " functions: ", _jsx(_components.code, { children: "gcc program.c -o program -lm" })] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Never use ", _jsx(_components.code, { children: "gets()" })] }), " — it is deprecated and unsafe because it does not check buffer size; always use ", _jsx(_components.code, { children: "fgets()" }), " instead"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Always check if ", _jsx(_components.code, { children: "malloc()" }), " or ", _jsx(_components.code, { children: "calloc()" }), " returned ", _jsx(_components.code, { children: "NULL" })] }), " — they return ", _jsx(_components.code, { children: "NULL" }), " when system runs out of memory"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Always call ", _jsx(_components.code, { children: "free()" }), " on dynamically allocated memory"] }), " — forgetting causes ", _jsx(_components.strong, { children: "memory leaks" }), " that can crash your program"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.code, { children: "getchar()" }), " returns ", _jsx(_components.code, { children: "int" }), ", not ", _jsx(_components.code, { children: "char" })] }), " — this is because it needs to represent both regular characters and the special ", _jsx(_components.code, { children: "EOF" }), " value"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.code, { children: "strlen()" }), " does NOT count the null terminator ", _jsx(_components.code, { children: "\\0" })] }), " — ", _jsx(_components.code, { children: "strlen(\"abc\")" }), " returns 3, not 4"] }), "\n"] }) }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "C provides hundreds of library functions organized into standard header files for reusable functionality" }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "math.h" }), " functions (", _jsx(_components.code, { children: "sqrt" }), ", ", _jsx(_components.code, { children: "pow" }), ", ", _jsx(_components.code, { children: "ceil" }), ", ", _jsx(_components.code, { children: "floor" }), ", ", _jsx(_components.code, { children: "fabs" }), ", trigonometric, logarithmic) work with floating-point numbers"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "string.h" }), " functions (", _jsx(_components.code, { children: "strlen" }), ", ", _jsx(_components.code, { children: "strcpy" }), ", ", _jsx(_components.code, { children: "strcmp" }), ", ", _jsx(_components.code, { children: "strcat" }), ", ", _jsx(_components.code, { children: "strchr" }), ", ", _jsx(_components.code, { children: "strstr" }), ") operate on null-terminated character arrays"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "getchar()" }), " reads one character from stdin; ", _jsx(_components.code, { children: "putchar()" }), " writes one character to stdout"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "malloc()" }), " allocates uninitialized memory; ", _jsx(_components.code, { children: "calloc()" }), " allocates zero-initialized memory; both require ", _jsx(_components.code, { children: "free()" }), " to release"] }), "\n", _jsx(_components.li, { children: "Always include the appropriate header file and link necessary libraries when using these functions" }), "\n", _jsxs(_components.li, { children: ["Check for ", _jsx(_components.code, { children: "NULL" }), " return values from memory allocation functions to handle failures gracefully"] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsxs(Prompt, { children: ["Write the prototype of the ", _jsx(_components.code, { children: "sqrt()" }), " function and explain its purpose with a simple example."] }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "sqrt()" }), " function is used to calculate the square root of a non-negative real number. ", _jsx(_components.strong, { children: "Prototype:" }), " ", _jsx(_components.code, { children: "double sqrt(double x);" }), " - It is defined in the header file ``. - The function takes a ", _jsx(_components.code, { children: "double" }), " argument ", _jsx(_components.code, { children: "x" }), " and returns the square root as a ", _jsx(_components.code, { children: "double" }), " value. - If the argument is negative, it may return a domain error (NaN). ", _jsx(_components.strong, { children: "Example Code:" }), " ", _jsx(_components.code, { children: "c #include #include int main() { double number = 25.0; double result = sqrt(number); printf("Square root of %.1f is %.1f\\n", number, result); return 0; } " }), " ", _jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: "Square root of 25.0 is 5.0" })] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsxs(Prompt, { children: ["Explain the difference between the string handling functions ", _jsx(_components.code, { children: "strcpy()" }), " and ", _jsx(_components.code, { children: "strncpy()" }), ". Provide their prototypes and mention when each is preferred."] }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["Both ", _jsx(_components.code, { children: "strcpy()" }), " and ", _jsx(_components.code, { children: "strncpy()" }), " are used to copy strings from a source to a destination, but they differ in safety and behavior. ", _jsx(_components.strong, { children: "Function Prototypes (from ``):" }), " - ", _jsx(_components.code, { children: "char *strcpy(char *dest, const char *src);" }), " - ", _jsx(_components.code, { children: "char *strncpy(char *dest, const char *src, size_t n);" }), " ", _jsx(_components.strong, { children: "Key Differences:" }), " 1. ", _jsx(_components.strong, { children: "Buffer Size Handling:" }), " - ", _jsx(_components.code, { children: "strcpy()" }), " copies the entire string (including the null terminator ", _jsx(_components.code, { children: "\\0" }), ") from ", _jsx(_components.code, { children: "src" }), " to ", _jsx(_components.code, { children: "dest" }), " without any limit. It is unsafe if the destination buffer is smaller than the source string, leading to a ", _jsx(_components.strong, { children: "buffer overflow" }), ". - ", _jsx(_components.code, { children: "strncpy()" }), " copies at most ", _jsx(_components.code, { children: "n" }), " characters from ", _jsx(_components.code, { children: "src" }), " to ", _jsx(_components.code, { children: "dest" }), ". It is safer for preventing buffer overflows. 2. ", _jsxs(_components.strong, { children: ["Null Terminator (", _jsx(_components.code, { children: "\\0" }), ") Handling:"] }), " - ", _jsx(_components.code, { children: "strcpy()" }), " always appends a null terminator to the destination. - ", _jsx(_components.code, { children: "strncpy()" }), " only appends the null terminator if ", _jsx(_components.code, { children: "n" }), " is larger than the length of the source string. If the source string is longer than or equal to ", _jsx(_components.code, { children: "n" }), ", the destination string may ", _jsx(_components.strong, { children: "not be null-terminated" }), ", which is a common bug. ", _jsx(_components.strong, { children: "Preferred Use Cases:" }), " - Use ", _jsx(_components.code, { children: "strcpy()" }), " ", _jsx(_components.strong, { children: "only" }), " when you are absolutely sure the destination buffer is large enough to hold the entire source string. - Use ", _jsx(_components.code, { children: "strncpy()" }), " when copying strings of unknown or variable length into a fixed-size buffer to prevent overflow. Always manually add the null terminator if ", _jsx(_components.code, { children: "strncpy()" }), " doesn't: ", _jsx(_components.code, { children: "dest[n-1] = '\\0';" }), ". ", _jsx(_components.code, { children: "strncpy()" }), " is not a perfect solution. For modern C programming, safer alternatives like ", _jsx(_components.code, { children: "snprintf()" }), " or dedicated string libraries are often recommended for complex operations."] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsxs(Prompt, { children: ["Explain the purpose and usage of the character I/O functions ", _jsx(_components.code, { children: "getchar()" }), " and ", _jsx(_components.code, { children: "putchar()" }), ". Also, describe the memory allocation functions ", _jsx(_components.code, { children: "malloc()" }), " and ", _jsx(_components.code, { children: "calloc()" }), ", highlighting their key differences with examples."] }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 Character I/O Functions (", _jsx(_components.code, { children: "getchar()" }), " and ", _jsx(_components.code, { children: "putchar()" }), ") These functions, from ", _jsx(_components.code, { children: ", are used for unformatted, character-by-character input and output. **`getchar()`** - **Prototype:** `int getchar(void);` - **Purpose:** Reads a single character from the standard input (usually the keyboard). - **Returns:** The character as an `int` value (to handle `EOF` as well). On failure or end-of-file, it returns `EOF`. - **Usage Example:** ```c int ch; printf("Enter a character: "); ch = getchar(); // Reads one character printf("You entered: %c\\n", ch); ``` **`putchar()`** - **Prototype:** `int putchar(int c);` - **Purpose:** Writes a single character to the standard output (usually the screen). - **Returns:** The character written as an `int`. On error, it returns `EOF`. - **Usage Example:** ```c putchar('A'); // Prints 'A' on screen putchar('\\n'); // Prints a newline ``` --- ### 🎯 Dynamic Memory Allocation Functions (`malloc()` and `calloc()`) These functions, from " }), ", are used to allocate memory dynamically (at runtime) from the heap. ", _jsxs(_components.strong, { children: [_jsx(_components.code, { children: "malloc()" }), " (Memory Allocation)"] }), " - ", _jsx(_components.strong, { children: "Prototype:" }), " ", _jsx(_components.code, { children: "void* malloc(size_t size);" }), " - ", _jsx(_components.strong, { children: "Purpose:" }), " Allocates a single contiguous block of memory of the specified ", _jsx(_components.code, { children: "size" }), " (in bytes). - ", _jsx(_components.strong, { children: "Key Behavior:" }), " The allocated memory is ", _jsx(_components.strong, { children: "uninitialized" }), " (contains garbage values). - ", _jsx(_components.strong, { children: "Returns:" }), " A ", _jsx(_components.code, { children: "void*" }), " pointer to the allocated memory block, or ", _jsx(_components.code, { children: "NULL" }), " if allocation fails. ", _jsxs(_components.strong, { children: [_jsx(_components.code, { children: "calloc()" }), " (Contiguous Allocation)"] }), " - ", _jsx(_components.strong, { children: "Prototype:" }), " ", _jsx(_components.code, { children: "void* calloc(size_t num, size_t size);" }), " - ", _jsx(_components.strong, { children: "Purpose:" }), " Allocates memory for an array of ", _jsx(_components.code, { children: "num" }), " elements, each of ", _jsx(_components.code, { children: "size" }), " bytes. Total bytes allocated = ", _jsx(_components.code, { children: "num * size" }), ". - ", _jsx(_components.strong, { children: "Key Behavior:" }), " The allocated memory is ", _jsx(_components.strong, { children: "initialized to zero" }), " (all bits set to 0). This is its main advantage over ", _jsx(_components.code, { children: "malloc()" }), ". - ", _jsx(_components.strong, { children: "Returns:" }), " A ", _jsx(_components.code, { children: "void*" }), " pointer to the allocated memory block, or ", _jsx(_components.code, { children: "NULL" }), " if allocation fails. ", _jsx(_components.strong, { children: "Key Differences & Example:" }), " | Feature | ", _jsx(_components.code, { children: "malloc()" }), " | ", _jsx(_components.code, { children: "calloc()" }), " | | :--- | :--- | :--- | | ", _jsx(_components.strong, { children: "Initialization" }), " | Uninitialized (garbage values) | Initialized to zero | | ", _jsx(_components.strong, { children: "Parameters" }), " | Single argument: total size in bytes | Two arguments: number of elements, size of each | | ", _jsx(_components.strong, { children: "Use Case" }), " | General purpose dynamic allocation | When you need an array initialized to zero | | ", _jsx(_components.strong, { children: "Fragmentation" }), " | Can cause more external fragmentation | Less fragmentation for arrays (allocates one contiguous block) | ", _jsx(_components.strong, { children: "Code Example:" }), " ", _jsx(_components.code, { children: "c #include #include int main() { int n = 5; // Using malloc: Array of 5 integers, values are garbage int *arr_malloc = (int*)malloc(n * sizeof(int)); // Using calloc: Array of 5 integers, all initialized to 0 int *arr_calloc = (int*)calloc(n, sizeof(int)); if (arr_malloc && arr_calloc) { printf("First value with malloc: %d (garbage)\\n", arr_malloc[0]); printf("First value with calloc: %d (zero)\\n", arr_calloc[0]); } // Always free dynamically allocated memory free(arr_malloc); free(arr_calloc); return 0; } " }), " ", _jsx(_components.strong, { children: "Important:" }), " Always check if the allocation was successful (pointer is not ", _jsx(_components.code, { children: "NULL" }), ") and always ", _jsx(_components.code, { children: "free()" }), " the memory when done to avoid memory leaks."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "4.2", children: [_jsx(MCQ, { questions: [{ "id": "862e3836-dec5-41f3-9bb2-e640361edf99", "q": "Which header file is required to use math functions like sqrt() and pow() in C?", "options": ["stdio.h", "math.h", "stdlib.h", "string.h"], "answer": 1, "hint": "Think about what header file is needed for math functions in C.", "explanation": "The math.h header file must be included to use math functions like sqrt(), pow(), ceil(), floor(), etc. without it the compiler will not recognize these functions." }, { "id": "e45e0249-4a21-4c0b-a8f4-d9431247e798", "q": "What is the key difference between malloc() and calloc()?", "options": ["malloc() initializes memory to zero, calloc() does not", "Both are exactly the same", "calloc() allocates and initializes memory to zero, malloc() does not initialize", "malloc() can only be used for arrays, calloc() for single variables"], "answer": 2, "hint": "Recall how malloc() allocates memory compared to calloc().", "explanation": "malloc() allocates a single block of memory of the specified size but does not initialize the memory. calloc() allocates memory for an array of elements and initializes all bytes to zero." }, { "id": "3cd1b7f3-a0dd-4f42-96f5-0cc38635ee8f", "q": "What does the getchar() function return?", "options": ["An integer representing the ASCII value of the character read", "A character directly as char type", "A string of characters", "Nothing, it stores the value in a global variable"], "answer": 0, "hint": "Think about the return type of the getchar() function.", "explanation": "getchar() reads a single character from the standard input (keyboard) and returns it as an int value. It returns the character as an integer (its ASCII value) or EOF on end of file." }, { "id": "ca7c3350-b5f7-4114-ba52-27fad5c19cbc", "q": "Which function is used to display a single character on the screen in C?", "options": ["printf()", "getc()", "gets()", "putchar()"], "answer": 3, "hint": "Remember what value is passed to putchar().", "explanation": "putchar() takes a single character (or its integer ASCII value) as an argument and writes it to the standard output (screen). It requires the stdio.h header file." }, { "id": "7873db5d-325d-4a40-9a9f-4067526dc83f", "q": "Which header file is required for string handling functions like strlen() and strcpy()?", "options": ["stdio.h", "string.h", "math.h", "stdlib.h"], "answer": 1, "hint": "Think about which header file contains strlen(), strcpy(), and strcat().", "explanation": "The string.h header file contains all standard string handling functions such as strlen(), strcpy(), strcat(), strcmp(), strncpy(), and strncat()." }, { "id": "4db07de7-9349-495f-84ce-293632d9dcd1", "q": "What is the output of printf('%d', abs(-7));?", "options": ["-7", "0", "7", "Compilation error"], "answer": 2, "hint": "Think about what the abs() function does with a negative integer.", "explanation": "The abs() function returns the absolute (non-negative) value of an integer. For abs(-5), the result is 5. It is declared in the stdlib.h header file." }, { "id": "97e57f10-6e7a-4784-a9d7-2d1526a57b5a", "q": "What does malloc(100) return if memory allocation is successful?", "options": ["A void pointer pointing to a block of 100 bytes of memory", "An integer value of 100", "A character array of size 100", "A null pointer always"], "answer": 0, "hint": "Recall the syntax of malloc() and what it needs as an argument.", "explanation": "malloc() takes the number of bytes to allocate as its argument and returns a pointer of type void* to the allocated memory block. It requires stdlib.h and returns NULL if allocation fails." }, { "id": "4afb4789-11db-44c6-89d2-7b490ee6720a", "q": "What will ceil(4.3) and floor(4.7) return respectively?", "options": ["4.0 and 4.0", "5.0 and 5.0", "4.0 and 5.0", "5.0 and 4.0"], "answer": 3, "hint": "Think about what ceil() and floor() do with decimal numbers.", "explanation": "ceil(4.3) returns 5.0 (rounds up to the nearest integer) and floor(4.7) returns 4.0 (rounds down to the nearest integer). Both functions return double values and are declared in math.h." }, { "id": "629847bf-a347-43cc-aa49-b74a183433c1", "q": "What does strcmp('abc', 'abc') return?", "options": ["1", "0", "-1", "Compilation error"], "answer": 1, "hint": "Think about what happens when you compare two strings using versus strcmp().", "explanation": "The strcmp() function compares two strings character by character based on their ASCII values. It returns 0 if both strings are equal, a negative value if the first string is less than the second, and a positive value if the first is greater. Strings cannot be compared using the operator in C." }, { "id": "4e415856-89ff-4e5f-9b8f-3e02c358bc44", "q": "How many arguments does calloc() accept compared to malloc()?", "options": ["calloc() takes 1 argument, malloc() takes 2", "Both take exactly 1 argument", "calloc() takes 2 arguments, malloc() takes 1", "Both take exactly 2 arguments"], "answer": 2, "hint": "Think about the difference in how malloc() and calloc() receive their arguments.", "explanation": "malloc() takes a single argument representing total bytes needed (e.g., malloc(n*sizeof(int))), while calloc() takes two arguments: the number of elements and the size of each element (e.g., calloc(n, sizeof(int))). calloc() also initializes memory to zero while malloc() does not." }], topicId: "4.2" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Library functions", seoDesc: "Master Library functions with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "library functions, library functions notes, library functions examples, diploma engineering notes, practice quiz, learningway" })] })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }