డిజిటల్ అసిస్టెంట్ కోసం కంప్యూటర్ సైన్స్ మరియు ఎలక్ట్రానిక్స్ · Chapter 6

C ప్రోగ్రామింగ్ మరియు OOP భావనలు

గుర్తుంచుకోవలసినవి

C అనేది నిర్మాణాత్మక (structured), ప్రక్రియాత్మక (procedural), అక్షర-భేదం గల భాష; దీనిని 1970ల ప్రారంభంలో బెల్ ల్యాబ్స్‌లో డెన్నిస్ రిచీ రూపొందించారు. ప్రోగ్రామ్ `main()` వద్ద మొదలవుతుంది, కంపైలర్ దానిని మెషీన్ కోడ్‌గా మారుస్తుంది.
డేటా రకాలు మరియు వాటి పరిమాణాలు, ఆపరేటర్లు మరియు ప్రాధాన్యత, నియంత్రణ స్టేట్‌మెంట్లు, లూప్‌లు, ఫంక్షన్లు, అరేలు, స్ట్రింగ్‌లు, పాయింటర్లు, స్ట్రక్చర్లు, ఫైల్ నిర్వహణ తెలుసుకోవాలి.
OOP కోడ్‌ను ఆబ్జెక్టుల చుట్టూ నిర్వహిస్తుంది. దీని నాలుగు స్తంభాలు ఎన్‌క్యాప్సులేషన్, అబ్స్ట్రాక్షన్, ఇన్హెరిటెన్స్, పాలిమార్ఫిజం. C++, Java OOPకి మద్దతు ఇస్తాయి; C ఇవ్వదు.

1. C ప్రాథమికాంశాలు

C ప్రోగ్రామ్‌లో ఇవి ఉంటాయి: హెడర్ ఫైళ్లు (`#include <stdio.h>`), `main()` ఫంక్షన్, డిక్లరేషన్లు, స్టేట్‌మెంట్లు. ప్రతి స్టేట్‌మెంట్ సెమీకోలన్‌తో ముగుస్తుంది. వ్యాఖ్యలు `//` (ఒక వరుస) మరియు `/* ... */` (అనేక వరుసలు). C అక్షర-భేదం గలది (case-sensitive) మరియు స్వేచ్ఛా రూపం (free-form) గలది. దశలు: సోర్స్ రాయడం (.c) → ప్రీప్రాసెస్ → కంపైల్ → అసెంబుల్ → లింక్ → ఎగ్జిక్యూటబుల్. కంపైలర్ మొత్తం ప్రోగ్రామ్‌ను ఒకేసారి అనువదిస్తుంది; ఇంటర్‌ప్రిటర్ వరుస వరుసగా అనువదిస్తుంది; అసెంబ్లర్ అసెంబ్లీ కోడ్‌ను అనువదిస్తుంది.

టోకెన్లు: కీవర్డ్‌లు (`int`, `if`, `while` వంటి రిజర్వ్ చేసిన పదాలు, క్లాసిక్ C లో 32), ఐడెంటిఫైయర్లు (పేర్లు: అక్షరాలు, అంకెలు, అండర్‌స్కోర్; అంకెతో మొదలు కాకూడదు; కీవర్డ్ కాకూడదు), స్థిరాంకాలు, స్ట్రింగ్‌లు, ఆపరేటర్లు, విరామ చిహ్నాలు.

ప్రాథమిక డేటా రకాలు (32/64-బిట్ వ్యవస్థలో సాధారణ పరిమాణాలు): `char` 1 బైట్, `int` 4 బైట్లు (పాత 16-బిట్ వ్యవస్థల్లో 2 బైట్లు), `float` 4 బైట్లు (సుమారు 6 దశాంశ అంకెలు), `double` 8 బైట్లు, `short` 2 బైట్లు, `long` 4 లేదా 8 బైట్లు. `void` అంటే విలువ లేదు. మాడిఫైయర్లు: `signed`, `unsigned`, `short`, `long`.

ఫార్మాట్ స్పెసిఫైయర్లు: `%d` int, `%f` float, `%lf` double, `%c` char, `%s` స్ట్రింగ్, `%x` హెక్స్, `%o` ఆక్టల్, `%u` unsigned, `%p` పాయింటర్. `printf()` ముద్రిస్తుంది; `scanf()` చదువుతుంది, సాధారణ చరరాశికి ముందు `&` కావాలి. ఎస్కేప్ సీక్వెన్స్‌లు: `\n` కొత్త వరుస, `\t` ట్యాబ్, `\\` బ్యాక్‌స్లాష్.

2. ఆపరేటర్లు

రకం	ఆపరేటర్లు
అంకగణిత	+ − * / %
సంబంధ (Relational)	< > <= >= == !=
తార్కిక (Logical)	&& \	\	!
అసైన్‌మెంట్	= += −= *= /= %=
ఇంక్రిమెంట్ / డిక్రిమెంట్	++ −−
బిట్‌వైజ్	& \	^ ~ << >>
షరతు (టెర్నరీ)	? :
ఇతరాలు	sizeof, కామా, & (చిరునామా), * (వద్ద ఉన్న విలువ)

ముఖ్య అంశాలు: `%` పూర్ణాంకాలతో మాత్రమే పనిచేస్తుంది. పూర్ణాంక భాగహారం భిన్నాన్ని వదిలేస్తుంది: 7/2 = 3. `==` పోలుస్తుంది, `=` అసైన్ చేస్తుంది. ప్రీ-ఇంక్రిమెంట్ `++a` ముందు మారుస్తుంది, తర్వాత వాడుతుంది; పోస్ట్-ఇంక్రిమెంట్ `a++` ముందు వాడుతుంది, తర్వాత మారుస్తుంది. ప్రాధాన్యత క్రమం (ఎక్కువ నుండి తక్కువకు): `()`, ఏకవాచక (`!`, `++`, `−−`), `* / %`, `+ −`, సంబంధ, సమానత్వ, `&&`, `||`, షరతు, అసైన్‌మెంట్. చాలా ద్విసంఖ్యా ఆపరేటర్ల అసోసియేటివిటీ ఎడమ నుండి కుడికి; అసైన్‌మెంట్ కుడి నుండి ఎడమకు. `&&`, `||`లలో మూల్యాంకనం ముందే ఆగిపోతుంది (షార్ట్ సర్క్యూట్). షిఫ్ట్‌లు: `x << 1` 2తో గుణిస్తుంది; `x >> 1` 2తో భాగిస్తుంది.

సాధించిన ఉదాహరణ: `int x = 10; x += 5; x %= 4;` అయితే x = 15, ఆ తర్వాత x = 3. మరొకటి: `int a = 5; int b = a++;` అయితే b = 5 మరియు a = 6.

3. నియంత్రణ స్టేట్‌మెంట్లు మరియు లూప్‌లు

నిర్ణయ స్టేట్‌మెంట్లు: `if`, `if-else`, `else if` నిచ్చెన, నెస్టెడ్ if, `switch-case`. `switch` int లేదా char విలువలపై పనిచేస్తుంది; `break` ఫాల్-త్రూను ఆపుతుంది; ఏ కేసూ సరిపోలకపోతే `default` నడుస్తుంది.
లూప్‌లు: `for` (లెక్క తెలిసినప్పుడు), `while` (ప్రవేశ-నియంత్రిత, ముందు షరతు), `do-while` (నిష్క్రమణ-నియంత్రిత, కనీసం ఒక్కసారి నడుస్తుంది).
జంప్: `break` లూప్ లేదా switch నుండి బయటకు వస్తుంది; `continue` తర్వాతి ఇటరేషన్‌కు దాటుతుంది; `goto` ఒక లేబుల్‌కు దూకుతుంది; `return` ఫంక్షన్ నుండి బయటకు వస్తుంది.

ఉదాహరణ: `for (i = 1; i <= 5; i++) sum += i;` అయితే sum = 15. `for(;;)` అనంత లూప్. C లో సున్నా కాని ఏ విలువైనా నిజం, సున్నా అబద్ధం.

4. ఫంక్షన్లు, అరేలు మరియు స్ట్రింగ్‌లు

ఫంక్షన్: పేరు గల కోడ్ బ్లాక్. దీనికి డిక్లరేషన్ (ప్రోటోటైప్), నిర్వచనం, కాల్ ఉంటాయి. కాల్ బై వాల్యూ ఒక కాపీని పంపుతుంది, కాబట్టి అసలు విలువ మారదు. కాల్ బై రెఫరెన్స్ చిరునామాను (పాయింటర్ల ద్వారా) పంపుతుంది, కాబట్టి అసలు విలువ మారవచ్చు. రికర్షన్ అంటే ఫంక్షన్ తనను తానే పిలవడం; దీనికి బేస్ కేస్ కావాలి: `fact(n) = n * fact(n-1)`, `fact(0) = 1`. `fact(5) = 120`. స్టోరేజ్ క్లాసులు: `auto` (డిఫాల్ట్ లోకల్), `register`, `static` (కాల్‌ల మధ్య విలువను నిలుపుకుంటుంది), `extern` (ఫైళ్లన్నింటిలో గ్లోబల్). లోకల్ చరరాశులు ఫంక్షన్ లోపల ఉంటాయి; గ్లోబల్ చరరాశులు అన్ని ఫంక్షన్లకు బయట ప్రకటిస్తారు.

అరే: ఒకే రకం మూలకాల సమూహం, నిరంతర మెమరీలో ఉంటుంది. ఇండెక్స్ 0 నుండి మొదలవుతుంది. `int a[5];` కు ఇండెక్స్‌లు 0 నుండి 4 వరకు. పరిమాణం = మూలకాల సంఖ్య × రకం పరిమాణం; 5 int లు, ఒక్కొక్కటి 4 బైట్లు చొప్పున 20 బైట్లు తీసుకుంటాయి. C అరే హద్దులను తనిఖీ చేయదు. ద్విమితీయ అరేలు వరుస వరుసగా నిల్వ అవుతాయి (row-major).

స్ట్రింగ్: నల్ అక్షరం `\0` తో ముగిసే అక్షరాల అరే. `char s[] = "ABC";` 4 బైట్లు తీసుకుంటుంది. `string.h` లోని లైబ్రరీ ఫంక్షన్లు: `strlen`, `strcpy`, `strcat`, `strcmp` (సమానమైతే 0 ఇస్తుంది). `ctype.h` లో `isalpha`, `toupper` ఉన్నాయి. `math.h` లో `sqrt`, `pow` ఉన్నాయి. `stdlib.h` లో `malloc`, `free`, `exit` ఉన్నాయి.

5. పాయింటర్లు, స్ట్రక్చర్లు మరియు ఫైళ్లు

పాయింటర్ మరొక చరరాశి చిరునామాను నిల్వ చేస్తుంది. `int *p = &x;` `&` చిరునామాను ఇస్తుంది; `*` ఆ చిరునామా వద్ద ఉన్న విలువను ఇస్తుంది. int పాయింటర్ పెంచినప్పుడు సాధారణంగా int పరిమాణం మేరకు ముందుకు కదులుతుంది. అరే పేరు దాని మొదటి మూలకం చిరునామా. NULL పాయింటర్ దేనినీ సూచించదు. డాంగ్లింగ్ పాయింటర్ విడుదల చేసిన మెమరీని సూచిస్తుంది. డైనమిక్ మెమరీ: `malloc` కేటాయిస్తుంది, `calloc` కేటాయించి సున్నాకు సెట్ చేస్తుంది, `realloc` పరిమాణం మారుస్తుంది, `free` మెమరీని విడుదల చేస్తుంది (అన్నీ `stdlib.h` నుండి).

స్ట్రక్చర్ (`struct`) వేర్వేరు రకాల అంశాలను సమూహం చేస్తుంది; సభ్యులను `.` తో (పాయింటర్‌తో అయితే `->` తో) చేరుకుంటారు. పరిమాణం కనీసం సభ్యుల మొత్తానికి సమానం (ప్యాడింగ్ వల్ల ఎక్కువ కావచ్చు). యూనియన్ సభ్యుల మధ్య ఒకే మెమరీ బ్లాక్‌ను పంచుతుంది; దాని పరిమాణం అతిపెద్ద సభ్యునికి సమానం; ఒక సమయంలో ఒక సభ్యుడు మాత్రమే చెల్లుబాటు అయ్యే విలువను కలిగి ఉంటాడు. enum 0 నుండి మొదలయ్యే పూర్ణాంక స్థిరాంకాలకు పేర్లు ఇస్తుంది. `typedef` ఒక రకానికి కొత్త పేరు పెడుతుంది.

ఫైల్ నిర్వహణ: `FILE *fp = fopen("a.txt", "r");` మోడ్‌లు: `r` చదవడం, `w` రాయడం (చెరిపేస్తుంది), `a` చివరన చేర్చడం, `r+`, `w+`. ఫంక్షన్లు: `fprintf`, `fscanf`, `fgetc`, `fputc`, `fgets`, `fclose`. `fopen` విఫలమైతే NULL ఇస్తుంది. `EOF` ఫైల్ ముగింపును సూచిస్తుంది. ప్రీప్రాసెసర్ వరుసలు `#` తో మొదలవుతాయి: `#include`, `#define` (మాక్రో), `#ifdef`.

6. డేటా స్ట్రక్చర్లు మరియు అల్గారిథమ్‌ల ప్రాథమికాంశాలు

స్టాక్ LIFO (push, pop); క్యూ FIFO (enqueue, dequeue); లింక్డ్ లిస్ట్ పాయింటర్లతో నోడ్లను నిల్వ చేస్తుంది. లీనియర్ సెర్చ్ ఒక్కొక్కటిగా తనిఖీ చేస్తుంది (చెత్త సందర్భంలో n పోలికలు); బైనరీ సెర్చ్కు క్రమబద్ధీకరించిన అరే కావాలి, అది పరిధిని సగానికి తగ్గిస్తుంది (సుమారు log₂n పోలికలు). సరళమైన సార్టింగ్‌లు: బబుల్, సెలెక్షన్, ఇన్సర్షన్ (సుమారు n² దశలు); మెర్జ్ సార్ట్, క్విక్ సార్ట్ సగటున వేగంగా ఉంటాయి (n log n). అల్గారిథమ్ అంటే దశలవారీ పరిష్కారం; ఫ్లోచార్ట్ దానిని చిహ్నాలతో చూపిస్తుంది (ప్రారంభం/ముగింపుకు అండాకారం, ఇన్‌పుట్/అవుట్‌పుట్‌కు సమాంతర చతుర్భుజం, ప్రక్రియకు దీర్ఘచతురస్రం, నిర్ణయానికి వజ్రాకారం).

7. ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ భావనలు

OOP వాస్తవ వస్తువులను ఆబ్జెక్టులుగా నమూనా చేస్తుంది. క్లాస్ అంటే బ్లూప్రింట్; ఆబ్జెక్ట్ అంటే క్లాస్ యొక్క ఒక ఉదాహరణ (instance). క్లాస్‌లో డేటా సభ్యులు, సభ్య ఫంక్షన్లు (మెథడ్‌లు) ఉంటాయి.

భావన	అర్థం
ఎన్‌క్యాప్సులేషన్	డేటా మరియు ఫంక్షన్లను క్లాస్‌లో కట్టి, ప్రాప్యత నియంత్రణతో (private, public, protected) డేటాను దాచడం
అబ్స్ట్రాక్షన్	అవసరమైన లక్షణాలను మాత్రమే చూపించి, వివరాలను దాచడం
ఇన్హెరిటెన్స్	చైల్డ్ (డెరైవ్డ్) క్లాస్ పేరెంట్ (బేస్) క్లాస్ లక్షణాలను పొందుతుంది; పునర్వినియోగం ఇస్తుంది
పాలిమార్ఫిజం	ఒకే పేరు, అనేక రూపాలు

పాలిమార్ఫిజం: *కంపైల్-టైమ్* (స్టాటిక్) ఫంక్షన్ ఓవర్‌లోడింగ్, ఆపరేటర్ ఓవర్‌లోడింగ్ ద్వారా; *రన్-టైమ్* (డైనమిక్) ఫంక్షన్ ఓవర్‌రైడింగ్, వర్చువల్ ఫంక్షన్ల ద్వారా. కన్‌స్ట్రక్టర్ అనేది ఆబ్జెక్ట్ సృష్టించినప్పుడు నడిచే ప్రత్యేక ఫంక్షన్; దానికి క్లాస్ పేరే ఉంటుంది, రిటర్న్ రకం ఉండదు. డిస్ట్రక్టర్ ఆబ్జెక్ట్ నాశనమైనప్పుడు నడుస్తుంది (C++ లో దాని పేరు `~` తో మొదలవుతుంది). ఇన్హెరిటెన్స్ రకాలు: సింగిల్, మల్టిపుల్, మల్టీలెవల్, హైరార్కికల్, హైబ్రిడ్. C++ క్లాసుల మల్టిపుల్ ఇన్హెరిటెన్స్‌ను అనుమతిస్తుంది; Java దానిని ఇంటర్‌ఫేస్‌ల ద్వారా మాత్రమే అనుమతిస్తుంది. C++ ను బ్జార్న్ స్ట్రౌస్ట్రప్ (Bjarne Stroustrup) "C with Classes" గా సృష్టించారు. Java ను సన్ మైక్రోసిస్టమ్స్‌లో జేమ్స్ గాస్లింగ్ (James Gosling) సృష్టించారు; బైట్‌కోడ్ మరియు జావా వర్చువల్ మెషీన్ (JVM) వల్ల ఇది ప్లాట్‌ఫామ్-స్వతంత్రమైనది. మెసేజ్ అంటే ఆబ్జెక్ట్ యొక్క మెథడ్‌ను పిలవడం. C++ అవుట్‌పుట్, ఇన్‌పుట్‌కు `cout <<`, `cin >>` వాడుతుంది; `new`, `delete` డైనమిక్ మెమరీని నిర్వహిస్తాయి.

సాధించిన ఉదాహరణలు

1. లూప్ అవుట్‌పుట్: `int i, s = 0; for (i = 1; i <= 4; i++) s = s + i * i;` అయితే 1 + 4 + 9 + 16 = 30.
2. పూర్ణాంక భాగహారం: `int a = 7, b = 2; float c = a / b;` 3.0 ని నిల్వ చేస్తుంది (ముందు పూర్ణాంక భాగహారం జరుగుతుంది). `float c = (float)a / b;` 3.5 ఇస్తుంది.
3. అరే పరిమాణం: int 4 బైట్లు అయితే `int a[10];` 10 × 4 = 40 బైట్లు తీసుకుంటుంది; చివరి మూలకం `a[9]`.
4. పాయింటర్: `int x = 5; int *p = &x; *p = 8;` x ను 8 కి మారుస్తుంది. `p` లో x చిరునామా ఉంటుంది.
5. స్విచ్: `switch(2) { case 1: a; case 2: b; case 3: c; break; }` లో, కేసు 2కి break లేనందున అమలు కేసు 2 వద్ద మొదలై కేసు 3కి ఫాల్-త్రూ అవుతుంది, కాబట్టి b మరియు c రెండూ నడుస్తాయి.
6. రికర్షన్: `fact(4) = 4 × 3 × 2 × 1 = 24`.
7. బైనరీ సెర్చ్: క్రమబద్ధీకరించిన 16 మూలకాల అరేలో చెత్త సందర్భంలో గరిష్ఠంగా 5 పోలికలు కావాలి, ఎందుకంటే log₂16 = 4, చివరి దశకు మరొకటి.

పరీక్ష ఉచ్చులు

`=` అసైన్ చేస్తుంది, `==` పోలుస్తుంది.
`while` ముందు పరీక్షిస్తుంది; `do-while` కనీసం ఒక్కసారి నడుస్తుంది.
కాల్ బై వాల్యూ కాలర్ చరరాశిని మార్చలేదు; మార్చాలంటే చిరునామా పంపాలి.
n అక్షరాల స్ట్రింగ్‌కు నల్ అక్షరం కోసం n + 1 బైట్లు కావాలి.
అరే ఇండెక్స్ 0 నుండి మొదలవుతుంది; చివరి ఇండెక్స్ పరిమాణం − 1.
స్ట్రక్చర్ సభ్యులకు వేర్వేరు మెమరీ ఉంటుంది; యూనియన్ సభ్యులు మెమరీని పంచుకుంటారు.
ఓవర్‌లోడింగ్ కంపైల్ సమయంలో; ఓవర్‌రైడింగ్ రన్ సమయంలో.
C ప్రక్రియాత్మకం; C++ ప్రక్రియాత్మక మరియు OOP రెండింటికీ మద్దతు ఇస్తుంది.

ఒక్కమాట జవాబులు

1. C ను డెన్నిస్ రిచీ అభివృద్ధి చేశారు.
2. C ప్రోగ్రామ్ అమలు `main()` వద్ద మొదలవుతుంది.
3. `%` శేషాన్ని ఇస్తుంది.
4. `break` లూప్ లేదా switch నుండి బయటకు వస్తుంది.
5. `\0` స్ట్రింగ్‌ను ముగిస్తుంది.
6. `&` చిరునామాను ఇస్తుంది; `*` ఆ చిరునామా వద్ద ఉన్న విలువను ఇస్తుంది.
7. `malloc` మెమరీని డైనమిక్‌గా కేటాయిస్తుంది.
8. యూనియన్ పరిమాణం దాని అతిపెద్ద సభ్యునికి సమానం.
9. క్లాస్ అంటే ఆబ్జెక్టుల బ్లూప్రింట్.
10. ఇన్హెరిటెన్స్ కోడ్ పునర్వినియోగాన్ని ఇస్తుంది.
11. ఆబ్జెక్ట్ సృష్టించినప్పుడు కన్‌స్ట్రక్టర్ నడుస్తుంది.
12. C++ ను బ్జార్న్ స్ట్రౌస్ట్రప్ సృష్టించారు.

సాధన ప్రశ్నలు

C భాషను అభివృద్ధి చేసినవారు
1. లైనస్ టోర్వాల్డ్స్
2. జేమ్స్ గోస్లింగ్
3. బ్జార్న్ స్ట్రౌస్ట్రప్
4. డెన్నిస్ రిచీ
సమాధానం
D. డెన్నిస్ రిచీ
The C language was developed by
1. Linus Torvalds
2. James Gosling
3. Bjarne Stroustrup
4. Dennis Ritchie
ప్రతి C ప్రోగ్రామ్ అమలు ఏ ఫంక్షన్ నుండి ప్రారంభమవుతుంది?
1. begin()
2. printf()
3. main()
4. start()
సమాధానం
C. main()
Execution of every C program begins from the function
1. begin()
2. printf()
3. main()
4. start()
పూర్ణాంకాన్ని ముద్రించడానికి ఉపయోగించే ఫార్మాట్ స్పెసిఫైయర్ ఏది?
1. %c
2. %d
3. %f
4. %s
సమాధానం
B. %d
Which format specifier is used to print an integer?
1. %c
2. %d
3. %f
4. %s
C లో స్టేట్‌మెంట్‌ను ముగించే చిహ్నం ఏది?
1. పూర్ణవిరామం
2. కోలన్
3. కామా
4. సెమీకోలన్
సమాధానం
D. సెమీకోలన్
Which symbol ends a statement in C?
1. Full stop
2. Colon
3. Comma
4. Semicolon
పూర్ణాంక భాగహారం శేషాన్ని ఇచ్చే ఆపరేటర్
1. *
2. &
3. /
4. %
సమాధానం
D. %
The operator that gives the remainder of integer division is
1. *
2. &
3. /
4. %
తన బాడీని కనీసం ఒక్కసారైనా అమలు చేస్తుందని హామీ ఉన్న లూప్ ఏది?
1. do-while
2. for
3. while
4. నెస్టెడ్ if
సమాధానం
A. do-while
Which loop is guaranteed to execute its body at least once?
1. do-while
2. for
3. while
4. nested if
లూప్ లేదా స్విచ్ నుండి వెంటనే బయటకు రావడానికి ఉపయోగించే కీవర్డ్ ఏది?
1. continue
2. break
3. goto మాత్రమే
4. exit loop
సమాధానం
B. break
Which keyword is used to leave a loop or switch immediately?
1. continue
2. break
3. goto only
4. exit loop
C లో స్ట్రింగ్ ఏ అక్షరంతో ముగుస్తుంది?
1. EOF
2. \n
3. \0
4. \t
సమాధానం
C. \0
A string in C ends with the character
1. EOF
2. \n
3. \0
4. \t
C అరేలో మొదటి మూలకం ఇండెక్స్
1. 1
2. -1
3. వినియోగదారు ఎంచుకునే ఏ విలువైనా
4. 0
సమాధానం
D. 0
The index of the first element of a C array is
1. 1
2. -1
3. Any value chosen by the user
4. 0
C లో వేరియబుల్ చిరునామాను ఇచ్చే ఆపరేటర్
1. &
2. %
3. *
4. ->
సమాధానం
A. &
In C, the operator that gives the address of a variable is
1. &
2. %
3. *
4. ->
OOPలో క్లాస్‌ను ఉత్తమంగా వర్ణించేది
1. హెడర్ ఫైల్
2. ఆబ్జెక్ట్‌లకు బ్లూప్రింట్
3. లూప్ స్టేట్‌మెంట్
4. ఫైల్ రకం
సమాధానం
B. ఆబ్జెక్ట్‌లకు బ్లూప్రింట్
A class in OOP is best described as
1. a header file
2. a blueprint for objects
3. a loop statement
4. a file type
ఒక క్లాస్ మరొక క్లాస్ లక్షణాలను పొందడానికి అనుమతించే OOP లక్షణం ఏది?
1. అబ్‌స్ట్రాక్షన్
2. ఓవర్‌లోడింగ్
3. ఇన్హెరిటెన్స్
4. ఎన్‌క్యాప్సులేషన్
సమాధానం
C. ఇన్హెరిటెన్స్
Which OOP feature allows a class to acquire the properties of another class?
1. Abstraction
2. Overloading
3. Inheritance
4. Encapsulation
డేటా, ఫంక్షన్లను క్లాస్‌లో కలిపి డేటాను దాచడాన్ని ఏమంటారు?
1. రికర్షన్
2. ఎన్‌క్యాప్సులేషన్
3. ఇన్హెరిటెన్స్
4. పాలిమార్ఫిజం
సమాధానం
B. ఎన్‌క్యాప్సులేషన్
Binding data and functions together in a class and hiding the data is
1. recursion
2. encapsulation
3. inheritance
4. polymorphism
C++ ను సృష్టించినవారు
1. బ్జార్న్ స్ట్రౌస్ట్రప్
2. గైడో వాన్ రాసమ్
3. జేమ్స్ గోస్లింగ్
4. డెన్నిస్ రిచీ
సమాధానం
A. బ్జార్న్ స్ట్రౌస్ట్రప్
Who created C++?
1. Bjarne Stroustrup
2. Guido van Rossum
3. James Gosling
4. Dennis Ritchie
int x = 10; x += 5; x %= 4; తర్వాత x విలువ ఎంత?
1. 15
2. 3
3. 5
4. 1
సమాధానం
B. 3
What is the value of x after: int x = 10; x += 5; x %= 4;
1. 15
2. 3
3. 5
4. 1
int a = 7, b = 2; float c = a / b; తర్వాత float c లో నిల్వ అయ్యే విలువ ఎంత?
1. 4.0
2. 2.0
3. 3.5
4. 3.0
సమాధానం
D. 3.0
What is stored in float c after: int a = 7, b = 2; float c = a / b;
1. 4.0
2. 2.0
3. 3.5
4. 3.0
for (i = 1; i <= 4; i++) s = s + i * i; (s ప్రారంభ విలువ 0) యొక్క అవుట్‌పుట్ మొత్తం ఎంత?
1. 10
2. 20
3. 30
4. 16
సమాధానం
C. 30
What is the output sum of: for (i = 1; i <= 4; i++) s = s + i * i; (s starts at 0)?
1. 10
2. 20
3. 30
4. 16
int 4 బైట్లు తీసుకుంటే, int అరే a[10] ఎన్ని బైట్లను ఆక్రమిస్తుంది?
1. 44
2. 10
3. 40
4. 14
సమాధానం
C. 40
An int array a[10] occupies how many bytes when int takes 4 bytes?
1. 44
2. 10
3. 40
4. 14
int a[10] డిక్లరేషన్‌కు చివరి చెల్లుబాటు అయ్యే ఇండెక్స్
1. 11
2. 8
3. 10
4. 9
సమాధానం
D. 9
For the declaration int a[10], the last valid index is
1. 11
2. 8
3. 10
4. 9
char అరేలో నిల్వ అయ్యే "ABC" స్ట్రింగ్‌కు కనీసం ఎన్ని బైట్లు అవసరం?
1. 3
2. 5
3. 4
4. 6
సమాధానం
C. 4
A string "ABC" stored in a char array needs at least how many bytes?
1. 3
2. 5
3. 4
4. 6
int x = 5; int *p = &x; ఉండగా, *p = 8; స్టేట్‌మెంట్
1. x ను 8 గా మారుస్తుంది
2. p ను 8 గా మారుస్తుంది
3. x చిరునామాను మారుస్తుంది
4. కంపైల్ ఎర్రర్‌కు కారణమవుతుంది
సమాధానం
A. x ను 8 గా మారుస్తుంది
With int x = 5; int *p = &x; the statement *p = 8; will
1. change x to 8
2. change p to 8
3. change the address of x
4. cause a compile error
యూనియన్ గురించి కింది వాటిలో సరైన ప్రవచనం ఏది?
1. దాని సభ్యులు ఒకే మెమరీని పంచుకుంటాయి
2. ప్రతి సభ్యునికి తన సొంత మెమరీ ఉంటుంది
3. అది ఒక సభ్యుడిని మాత్రమే కలిగి ఉండగలదు
4. దాని పరిమాణం సభ్యుల మొత్తానికి సమానం
సమాధానం
A. దాని సభ్యులు ఒకే మెమరీని పంచుకుంటాయి
Which of the following is a correct statement about a union?
1. Its members share the same memory
2. Each member has its own memory
3. It can hold only one member
4. Its size equals the sum of members
ఆర్గ్యుమెంట్ల కాపీలను పంపే ఫంక్షన్ కాల్
1. రికర్షన్
2. ఓవర్‌లోడింగ్
3. కాల్ బై రెఫరెన్స్
4. కాల్ బై వాల్యూ
సమాధానం
D. కాల్ బై వాల్యూ
A function call that passes copies of the arguments is
1. recursion
2. overloading
3. call by reference
4. call by value
fact(5) ను n × fact(n−1) తో రికర్సివ్‌గా లెక్కిస్తే, fact(0) = 1 ఉండగా, విలువ
1. 60
2. 120
3. 720
4. 24
సమాధానం
B. 120
fact(5) computed recursively as n × fact(n−1) with fact(0) = 1 equals
1. 60
2. 120
3. 720
4. 24
రన్ టైమ్‌లో మెమరీని కేటాయించే stdlib.h ఫంక్షన్ ఏది?
1. strlen()
2. sqrt()
3. malloc()
4. printf()
సమాధానం
C. malloc()
Which function from stdlib.h allocates memory at run time?
1. strlen()
2. sqrt()
3. malloc()
4. printf()
రెండు స్ట్రింగ్‌లను పోల్చి, సమానమైతే 0 ఇచ్చే ఫంక్షన్ ఏది?
1. strlen()
2. strcat()
3. strcpy()
4. strcmp()
సమాధానం
D. strcmp()
Which function compares two strings and returns 0 if they are equal?
1. strlen()
2. strcat()
3. strcpy()
4. strcmp()
fopen()లో పాత విషయాలను తొలగించి ఫైల్‌ను రాయడానికి తెరిచే ఫైల్ మోడ్ ఏది?
1. "r"
2. "w"
3. "r+"
4. "a"
సమాధానం
B. "w"
Which file mode in fopen() erases the old contents and opens the file for writing?
1. "r"
2. "w"
3. "r+"
4. "a"
స్టాక్ డేటా నిర్మాణ లక్షణం ఏది?
1. ముందు వచ్చినది ముందు వెళ్తుంది
2. యాదృచ్ఛిక యాక్సెస్ మాత్రమే
3. చివరిగా వచ్చినది ముందు వెళ్తుంది
4. క్రమబద్ధీకరించిన క్రమం మాత్రమే
సమాధానం
C. చివరిగా వచ్చినది ముందు వెళ్తుంది
Which one is a stack data structure property?
1. First in, first out
2. Random access only
3. Last in, first out
4. Sorted order only
16 మూలకాలున్న క్రమబద్ధీకరించిన అరేలో బైనరీ సెర్చ్‌కు గరిష్ఠ పోలికల సంఖ్య సుమారు
1. 16
2. 8
3. 2
4. 5
సమాధానం
D. 5
The maximum number of comparisons for binary search in a sorted array of 16 elements is about
1. 16
2. 8
3. 2
4. 5
కంపైల్-టైమ్ పాలిమార్ఫిజం సాధించబడేది
1. ఫంక్షన్ ఓవర్‌లోడింగ్ ద్వారా
2. ఫంక్షన్ ఓవర్‌రైడింగ్ ద్వారా
3. వర్చువల్ ఫంక్షన్ల ద్వారా
4. డిస్ట్రక్టర్ల ద్వారా
సమాధానం
A. ఫంక్షన్ ఓవర్‌లోడింగ్ ద్వారా
Compile-time polymorphism is achieved through
1. function overloading
2. function overriding
3. virtual functions
4. destructors
C++ లో కన్‌స్ట్రక్టర్‌కు ఉండేది
1. ~ తో మొదలయ్యే పేరు
2. క్లాస్ పేరే ఉండి రిటర్న్ రకం ఉండదు
3. void రిటర్న్ రకం మాత్రమే
4. క్లాస్ పేరుతో సంబంధం ఉండదు
సమాధానం
B. క్లాస్ పేరే ఉండి రిటర్న్ రకం ఉండదు
A constructor in C++ has
1. a name starting with ~
2. the same name as the class and no return type
3. only a void return type
4. no relation to the class name
కండిషనల్ ఆపరేటర్ గురించి సరైన ప్రవచనం ఏది?
1. దానికి రెండు ఆపరాండ్‌లు ఉంటాయి
2. దానికి ఒక ఆపరాండ్ ఉంటుంది
3. దానికి మూడు ఆపరాండ్‌లు ఉంటాయి
4. అది స్ట్రింగ్‌లతో మాత్రమే పనిచేస్తుంది
సమాధానం
C. దానికి మూడు ఆపరాండ్‌లు ఉంటాయి
Which statement about the conditional operator is correct?
1. It takes two operands
2. It takes one operand
3. It takes three operands
4. It works only with strings
C లో for(;;) లూప్
1. అనంత లూప్
2. ఒక్కసారి నడిచే లూప్
3. ఎప్పుడూ ప్రారంభం కాని లూప్
4. సింటాక్స్ ఎర్రర్
సమాధానం
A. అనంత లూప్
In C, the loop for(;;) is
1. an infinite loop
2. a loop that runs once
3. a loop that never starts
4. a syntax error
switch(2) { case 1: a; case 2: b; case 3: c; break; case 4: d; } ను పరిశీలించండి. a, b, c, d లలో ఏవి అమలవుతాయి?
1. b మరియు c
2. b మాత్రమే
3. a, b మరియు c
4. b, c మరియు d
సమాధానం
A. b మరియు c
Consider switch(2) { case 1: a; case 2: b; case 3: c; break; case 4: d; }. Which of a, b, c, d are executed?
1. b and c
2. only b
3. a, b and c
4. b, c and d
C గురించి కింది ప్రవచనాలను పరిశీలించండి. 1. C కేస్-సెన్సిటివ్. 2. ప్రతి ఐడెంటిఫైయర్ అంకెతో ప్రారంభం కావచ్చు. ఏది/ఏవి సరైనవి?
1. 1 మాత్రమే
2. 2 మాత్రమే
3. 1 మరియు 2 రెండూ
4. 1 లేదా 2 కాదు
సమాధానం
A. 1 మాత్రమే
Consider these statements about C. 1. C is case-sensitive. 2. Every identifier may start with a digit. Which is/are correct?
1. 1 only
2. 2 only
3. Both 1 and 2
4. Neither 1 nor 2
లూప్‌ల గురించి కింది ప్రవచనాలను పరిశీలించండి. 1. while లూప్ బాడీకి ముందు కండిషన్‌ను పరీక్షిస్తుంది. 2. do-while లూప్ బాడీ తర్వాత కండిషన్‌ను పరీక్షిస్తుంది. ఏది/ఏవి సరైనవి?
1. 1 మాత్రమే
2. 2 మాత్రమే
3. 1 మరియు 2 రెండూ
4. 1 లేదా 2 కాదు
సమాధానం
C. 1 మరియు 2 రెండూ
Consider these statements about loops. 1. A while loop tests its condition before the body. 2. A do-while loop tests its condition after the body. Which is/are correct?
1. 1 only
2. 2 only
3. Both 1 and 2
4. Neither 1 nor 2
ఫంక్షన్ల గురించి కింది ప్రవచనాలను పరిశీలించండి. 1. కాల్ బై రెఫరెన్స్ అసలు వేరియబుల్‌ను మార్చగలదు. 2. రికర్షన్‌కు బేస్ కేస్ అవసరం. ఏది/ఏవి సరైనవి?
1. 1 మాత్రమే
2. 2 మాత్రమే
3. 1 మరియు 2 రెండూ
4. 1 లేదా 2 కాదు
సమాధానం
C. 1 మరియు 2 రెండూ
Consider these statements about functions. 1. Call by reference can change the original variable. 2. Recursion needs a base case. Which is/are correct?
1. 1 only
2. 2 only
3. Both 1 and 2
4. Neither 1 nor 2
స్ట్రక్చర్లు, యూనియన్ల గురించి కింది ప్రవచనాలను పరిశీలించండి. 1. స్ట్రక్చర్‌లోని ప్రతి సభ్యునికి సొంత మెమరీ ఉంటుంది. 2. యూనియన్ అన్ని సభ్యులలో ఒకేసారి చెల్లుబాటు అయ్యే విలువలను ఉంచగలదు. ఏది/ఏవి సరైనవి?
1. 1 మాత్రమే
2. 2 మాత్రమే
3. 1 మరియు 2 రెండూ
4. 1 లేదా 2 కాదు
సమాధానం
A. 1 మాత్రమే
Consider these statements about structures and unions. 1. Each member of a structure has its own memory. 2. A union can hold valid values in all members at the same time. Which is/are correct?
1. 1 only
2. 2 only
3. Both 1 and 2
4. Neither 1 nor 2
OOP గురించి కింది ప్రవచనాలను పరిశీలించండి. 1. ఫంక్షన్ ఓవర్‌లోడింగ్ రన్-టైమ్ పాలిమార్ఫిజం. 2. ఫంక్షన్ ఓవర్‌రైడింగ్ రన్-టైమ్ పాలిమార్ఫిజం. ఏది/ఏవి సరైనవి?
1. 1 మాత్రమే
2. 2 మాత్రమే
3. 1 మరియు 2 రెండూ
4. 1 లేదా 2 కాదు
సమాధానం
B. 2 మాత్రమే
Consider these statements about OOP. 1. Function overloading is run-time polymorphism. 2. Function overriding is run-time polymorphism. Which is/are correct?
1. 1 only
2. 2 only
3. Both 1 and 2
4. Neither 1 nor 2
C, OOP గురించి కింది ప్రవచనాలను పరిశీలించండి. 1. C ఒక ప్రొసీజరల్ భాష. 2. C++ ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌ను మద్దతు ఇస్తుంది. ఏది/ఏవి సరైనవి?
1. 1 మాత్రమే
2. 2 మాత్రమే
3. 1 మరియు 2 రెండూ
4. 1 లేదా 2 కాదు
సమాధానం
C. 1 మరియు 2 రెండూ
Consider these statements about C and OOP. 1. C is a procedural language. 2. C++ supports object-oriented programming. Which is/are correct?
1. 1 only
2. 2 only
3. Both 1 and 2
4. Neither 1 nor 2
పాయింటర్ల గురించి కింది ప్రవచనాలను పరిశీలించండి. 1. పాయింటర్ ఒక వేరియబుల్ చిరునామాను నిల్వ చేస్తుంది. 2. అరే పేరు దాని మొదటి మూలకం చిరునామాను ఇస్తుంది. ఏది/ఏవి సరైనవి?
1. 1 మాత్రమే
2. 2 మాత్రమే
3. 1 మరియు 2 రెండూ
4. 1 లేదా 2 కాదు
సమాధానం
C. 1 మరియు 2 రెండూ
Consider these statements about pointers. 1. A pointer stores the address of a variable. 2. The array name gives the address of its first element. Which is/are correct?
1. 1 only
2. 2 only
3. Both 1 and 2
4. Neither 1 nor 2
అంశాన్ని దాని అర్థంతో జతపరచండి. P. malloc Q. free R. sizeof 1. మెమరీని విడుదల చేస్తుంది 2. మెమరీని కేటాయిస్తుంది 3. రకం లేదా వేరియబుల్ పరిమాణాన్ని ఇస్తుంది
1. P-2, Q-3, R-1
2. P-1, Q-2, R-3
3. P-3, Q-1, R-2
4. P-2, Q-1, R-3
సమాధానం
D. P-2, Q-1, R-3
Match the item with its meaning. P. malloc Q. free R. sizeof 1. Releases memory 2. Allocates memory 3. Gives size of a type or variable
1. P-2, Q-3, R-1
2. P-1, Q-2, R-3
3. P-3, Q-1, R-2
4. P-2, Q-1, R-3
ఫ్లోచార్ట్ చిహ్నాన్ని దాని ఉపయోగంతో జతపరచండి. P. సమాంతర చతుర్భుజం Q. వజ్రాకారం R. అండాకారం 1. ప్రారంభం లేదా ముగింపు 2. ఇన్‌పుట్ లేదా అవుట్‌పుట్ 3. నిర్ణయం
1. P-3, Q-2, R-1
2. P-2, Q-1, R-3
3. P-1, Q-3, R-2
4. P-2, Q-3, R-1
సమాధానం
D. P-2, Q-3, R-1
Match the flowchart symbol with its use. P. Parallelogram Q. Diamond R. Oval 1. Start or stop 2. Input or output 3. Decision
1. P-3, Q-2, R-1
2. P-2, Q-1, R-3
3. P-1, Q-3, R-2
4. P-2, Q-3, R-1
OOP భావనను దాని అర్థంతో జతపరచండి. P. అబ్‌స్ట్రాక్షన్ Q. పాలిమార్ఫిజం R. ఇన్హెరిటెన్స్ 1. ఒకే పేరు, అనేక రూపాలు 2. అవసరమైన వివరాలను మాత్రమే చూపడం 3. పేరెంట్ క్లాస్ లక్షణాలను తిరిగి ఉపయోగించడం
1. P-3, Q-1, R-2
2. P-2, Q-1, R-3
3. P-1, Q-2, R-3
4. P-2, Q-3, R-1
సమాధానం
B. P-2, Q-1, R-3
Match the OOP concept with its meaning. P. Abstraction Q. Polymorphism R. Inheritance 1. One name, many forms 2. Showing only essential details 3. Reusing a parent class's properties
1. P-3, Q-1, R-2
2. P-2, Q-1, R-3
3. P-1, Q-2, R-3
4. P-2, Q-3, R-1
C++ లో Box అనే క్లాస్ డిస్ట్రక్టర్ కింది వాటిలో ఏది?
1. !Box()
2. ~Box()
3. Box()
4. delete Box
సమాధానం
B. ~Box()
Which of the following is the destructor of a class named Box in C++?
1. !Box()
2. ~Box()
3. Box()
4. delete Box

Page 1 of 1

Finished reading?

Test yourself in 10 minutes

A free 10-question mini-mock on your exam's real pattern, with negative marking and an instant score. अपनी तैयारी 10 मिनट में जाँचें।

Take a free mini-mock →Topic-wise practice