सवाल का पहला सेट
नीचे दिए गए प्रोग्राम को पढ़ें और इसके बाद, इन सवालों के जवाब दें. हम चाहते हैं कि आप सवालों के जवाब सिर्फ़ सोर्स कोड को देखकर दें. उदाहरण के लिए, कृपया इसे किसी फ़ाइल में कॉपी न करें, इसे कंपाइल करें, और सवालों के जवाब देने के लिए इसका इस्तेमाल करें. इससे आनंद लेने में ही आनंद आएगा!
int main() {
int counter, first, last, next;
first = 1; last = 2;
for (counter = first; counter <= last; counter++) {
cout << "\n " << counter;
next = counter * counter;
cout << " " << next;
}
counter = first;
while (counter <= last) {
cout << "\n " << counter;
next = counter * counter;
cout << " " << next;
counter++;
}
counter = first;
do {
cout << "\n " << counter;
next = counter * counter;
cout << " " << next;
counter++;
} while (counter < last);
}
पहला सवाल: इस प्रोग्राम से क्या फ़ायदा होगा?
| A) |
1 2 2 4 1 2 2 4 1 2 2 4 |
| B) |
1 1 2 4 1 1 2 4 1 1 2 4 |
| C) |
1 1 2 4 1 1 2 4 1 1 |
| ड) |
1 1 2 4 1 1 1 1 2 4 |
| E) | यह कुछ भी आउटपुट नहीं करता है - सिंटैक्स में गड़बड़ियां हैं. |
दूसरा सवाल: अगर हम 'डू-टाइम लूप' से पहले, "काउंटर" शुरू करने की सुविधा हटा दें, तो क्या होगा?
| A) | अनंत लूप - 'करते समय करें' लूप, 1's की एक शृंखला देता है |
| B) | प्रोग्राम का आउटपुट नहीं बदलेगा |
| C) | 'ड्यू-टाइम लूप' से 2 और 4 मिलता है. |
| ड) | ' तभी करें' लूप में कुछ भी आउटपुट नहीं होगा |
| E) | 'क्या करें' लूप में 3 और 9 मिलता है. |
तीसरा सवाल: इस पेज के सबसे ऊपर दिए गए मूल प्रोग्राम को देखते हुए, मान लें कि हमने उस लाइन को हटा दिया है जो लूप के दौरान, काउंटर वैरिएबल को शुरू करने से पहले शुरू करती है. अगर हम लूप के दौरान हुई काउंटर++ लाइन को भी हटा दें, तो क्या होगा, जैसा कि यहां बताया गया है?
| A) | जबकि लूप, आउटपुट के तौर पर कुछ नहीं दिखाता. |
| B) | जबकि लूप, 1 और 1 दिखाता है. 'इस समय करें' लूप में कुछ भी आउटपुट नहीं होता है. |
| C) | दोनों लाइनों को शामिल करने पर, 'टाइम लूप' का आउटपुट एक ही होता है. |
| ड) | जब तक हम कंप्यूटर को बंद नहीं कर देते, तब तक सिस्टम बिना किसी क्रम के नंबर दिखाता रहेगा. |
| E) | जबकि लूप एक अनंत लूप होता है |
चौथा सवाल: इस पेज में सबसे ऊपर मौजूद मूल प्रोग्राम को देखते हुए क्या होगा अगर लूप ऐसा दिखे?
counter = first;
while (counter <= last) {
cout << "\n" << counter;
if (first % 2 == 0)
next = counter * counter;
cout << " " << next;
counter++;
}
| A) | लूप के दौरान का आउटपुट, मूल प्रोग्राम जैसा ही होता है. |
| B) | जबकि लूप कुछ भी आउटपुट नहीं करेगा |
| C) | जबकि लूप का आउटपुट 1 1 और 1 4 होता है. |
| ड) | जबकि लूप का आउटपुट 1 2 और 2 4 है. |
| E) | जबकि लूप का आउटपुट 1 4 और 2 4 है. |
| शु) | जबकि लूप का आउटपुट 2 4 और 2 4 है. |
पांचवां सवाल: अगर पहला वैरिएबल आखिरी वैरिएबल से ज़्यादा है, तो क्या होगा?
| A) | टाइम-लूप से कुछ आउटपुट होगा, लेकिन कोई और नहीं. |
| B) | 'डू टाइम-लूप' से कुछ आउटपुट होगा, लेकिन किसी से नहीं. |
| C) | कोई आउटपुट नहीं मिलेगा. |
| ड) | प्रोग्राम में गड़बड़ी या क्रैश होने का पता लगाया जाएगा |
| E) | फ़ॉर-लूप में कुछ आउटपुट होगा, लेकिन कोई और नहीं. |
छठा सवाल: अगर हम पहले वैरिएबल को आखिरी वैरिएबल से शुरू करते हैं, तो प्रोग्राम का आउटपुट क्या होगा?
| A) | 'डू टाइम-लूप' से कुछ आउटपुट होगा, लेकिन किसी से नहीं. |
| B) | टाइम-लूप से कुछ आउटपुट होगा, लेकिन कोई और नहीं. |
| C) | हर लूप के लिए एक लाइन जनरेट होगी. |
| ड) | 'डू टाइम-लूप' से दो लाइन जनरेट होंगी और दूसरा लूप एक लाइन दिखाएगा. |
| E) | इससे कोई आउटपुट नहीं मिलेगा |
| शु) | फ़ॉर-लूप में कुछ आउटपुट होगा, लेकिन कोई और नहीं. |
सवाल का सेट 2
समस्या के पिछले सेट की तरह, यहां आपके विचार के लिए एक प्रोग्राम दिया गया है. कृपया सिर्फ़ सोर्स कोड को देखकर ही आने वाले सवालों के जवाब दें.
#include <iostream>
using namespace std;
int main() {
int Boys = 3, Girls = 5;
void F1(int males, int females);
void F2(int &m, int &f);
F1(Boys, Girls);
cout << "\nAfter calling F1, within main()";
cout << "\n\tBoys = " << Boys; // #2
cout << "\n\tGirls = " << Girls;
F2(Boys, Girls);
cout << "\nAfter calling F2, within main()";
cout << "\n\tBoys = " << Boys; // #4
cout << "\n\tGirls = " << Girls;
}
void F1(int b, int g) {
b += 3, g += 4;
cout << "\nF1";
cout << "\n\tBoys = " << b; // #1
cout << "\n\tGirls = " << g;
}
void F2(int &b, int &g) {
b = b + 8, g = g + 5;
cout << "\nF2";
cout << "\n\tBoys = " << b; // #3
cout << "\n\tGirls = " << g;
}
पहला सवाल: मार्क की गई लाइनों पर ब्वायज़ वैरिएबल का आउटपुट क्या है?
| A) |
#1: 6 #2: 3 #3: 11 #4: 11 |
| B) |
#1: 6 #2: 3 #3: 11 #4: 3 |
| C) |
#1: 6 #2: 6 #3: 11 #4: 11 |
| ड) | यह कुछ भी आउटपुट नहीं करता है, क्योंकि यह कंपाइल या चलता नहीं है. |
दूसरा सवाल: कार्यक्रम की इन लाइनों पर लागू होने वाले सभी विकल्प चुनें:
void F1(int males, int females); void F2(int &m, int &f);
| A) | C++ नियमों के मुताबिक, जब तक इन तरीकों का इस्तेमाल करने से पहले इनके बारे में बताया जाता है, तब तक इन दो लाइनों को हटाया जा सकता है. |
| B) | C++ नियमों के मुताबिक, एलान और परिभाषा में आर्ग्युमेंट के नाम एक जैसे होने चाहिए. |
| C) | अगर हम इन दो लाइनों को हटा देते हैं, तो यह प्रोग्राम बंद हो जाएगा. |
| ड) | आम तौर पर, एलानों को ग्लोबल स्कोप में बताया जाता है. |
| E) | इन्हें फ़ॉरवर्ड डिक्लेरेशन कहा जाता है. |
तीसरा सवाल: अगर हम नीचे दी गई लाइन को मुख्य() से ले जाएं और उसे ग्लोबल स्कोप में रखें, तो क्या होगा?
int Boys = 3, Girls = 5;
| A) | आउटपुट भी वही होगा. |
| B) | लड़कों के लिए = 3 होगा और लड़कियों के नतीजे = 5 होंगे |
| C) | लड़कों का मान = 3 होगा और लड़कियों के लिए = 5 होना चाहिए. इसलिए, आपको म्यूज़िक का इस्तेमाल करने पर ज़्यादा पॉइंट मिलेंगे |
चौथा सवाल: अगर हम प्रोग्राम की शुरुआत में ऐसा बदलाव करें, तो क्या होगा:
// We have moved moved these to global scope
const int Boys = 3;
const int Girls = 5;
void main() {
//int Boys = 3, Girls = 5;
| A) | प्रोग्राम कंपाइल होगा, लेकिन जब हम इसे चलाने की कोशिश करेंगे, तो यह क्रैश हो जाएगा. |
| B) | आउटपुट में कोई बदलाव नहीं होगा |
| C) | पूरे प्रोग्राम के दौरान, लड़कों की संख्या = 3 लड़कियां = 5 होगी |
| ड) | मुख्य() से मिलने वाले आउटपुट में, लड़के के लिए = 3 लड़कियां = 5 आउटपुट होगा |
| E) | यह प्रोग्राम कंपाइल नहीं करेगा, क्योंकि यह कंपाइलर पर निर्भर करता है. |
पांचवां सवाल: डेटा को F2 में वैल्यू के हिसाब से भेजा जाता है.
| A) | सही. |
| B) | गलत. |
सवाल का तीसरा सवाल
समस्या के पिछले सेट की तरह, यहां आपके विचार के लिए एक प्रोग्राम दिया गया है. कृपया सिर्फ़ सोर्स कोड को देखकर, पूछे गए सवालों के जवाब दें.यह पिछले दो के मुकाबले ज़्यादा दिलचस्प है - कोड को ध्यान से ट्रेस करें.
#include <iostream>
using namespace std;
const int MAX_SIZE = 20;
typedef int ARR2D[MAX_SIZE][MAX_SIZE];
void Print(ARR2D in_array, int rows, int cols);
void Fill(ARR2D in_array, int rows, int cols);
int main() {
ARR2D matrix;
int row, col;
do {
cout << "Please enter the size of the matrix to generate (rows and cols) :" << endl;
cin >> row >> col;
} while (row <= 0 || row > MAX_SIZE || col <= 0 || col > MAX_SIZE);
Fill(matrix, row, col);
Print(matrix, row, col);
return(0);
}
void Print(ARR2D in_array, int rows, int cols) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++)
cout << '\t' << in_array[i][j];
cout << endl;
}
}
void Fill(ARR2D in_array, int rows, int cols) {
for(int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++)
in_array[i][j] = 0;
const int limit = rows * cols;
int cNum = 1;
int cRow = 0;
int cCol = 0;
int cDir = 0; // 0-north, 1-east, 2-south, 3-west
while(true) {
// Place the number.
in_array[cRow][cCol] = cNum;
cNum++;
if (cNum > limit) break;
int fRow = cRow;
int fCol = cCol;
while (true) {
fRow = cRow;
fCol = cCol;
switch(cDir) {
case 0: fRow--; break;
case 1: fCol++; break;
case 2: fRow++; break;
case 3: fCol--; break;
}
if ( fRow >= 0 && fRow < rows && fCol >= 0 && fCol < cols && in_array[fRow][fCol] == 0)
break;
cDir = (cDir + 1) % 4;
}
cRow = fRow;
cCol = fCol;
}
}
पहला सवाल: इस प्रोग्राम में पंक्तियों के लिए 3 और कॉलम के लिए 4 इनपुट के साथ क्या आउटपुट मिलता है?
| A) |
1 2 3 4 5 6 7 8 9 10 11 12 |
| B) |
1 2 3 4 5 6 7 8 9 10 11 12 |
| C) |
12 11 10 9 8 7 6 5 4 3 2 1 |
| ड) |
1 3 2 4 8 6 7 5 9 11 10 12 |
| E) |
1 2 3 4 10 11 12 5 9 8 7 6 |
| ग) |
9 8 7 6 10 11 12 5 1 2 3 4 |
| हर) | यह कुछ भी आउटपुट नहीं करता है - तर्क में गड़बड़ी है. |
| I) | यह कुछ भी आउटपुट नहीं करता - इसमें सिंटैक्स की गड़बड़ियां हैं. |
| ज) | यह कुछ भी आउटपुट नहीं करता है - ऐसा नहीं होना चाहिए. |
| क) | इसमें प्रोग्राम के चालू होने का इंतज़ार करते समय, दिमाग में आने वाले शुरुआती 12 नंबर शामिल होते हैं. |
दूसरा सवाल: अगर हम नीचे दी गई लाइन को अपने मुख्य() फ़ंक्शन में जोड़ दें, तो क्या होगा?
MAX_SIZE = 10;
| A) | C++ में इसकी अनुमति नहीं है. |
| B) | इसकी अनुमति है; प्रोग्राम 20 पर सेट MAX_SIZE के साथ चलेगा |
| C) | इसकी अनुमति है; प्रोग्राम 10 पर सेट MAX_SIZE के साथ चलेगा. |
तीसरा सवाल: ऊपर दिए गए प्रोग्राम की इन चार लाइनों पर ध्यान दें:
const int MAX_SIZE = 20; typedef int ARR2D [MAX_SIZE][MAX_SIZE]; void Print (ARR2D A, int rows, int cols); void Fill (ARR2D A, int rows, int cols);
1) क्या टाइपडेफ़ में कॉन्सट का इस्तेमाल किया जा सकता है?
2) क्या किसी वैरिएबल को उस टाइप का एलान किए जाने से पहले, एलान में typedef का इस्तेमाल किया जा सकता है?
| A) | 1) हां 2) हां |
| B) | 1) नहीं 2) नहीं |
| C) | 1) नहीं 2) हां |
| ड) | 1) हां 2) नहीं |
चौथा सवाल: क्या हम इनका इस्तेमाल कर सकते हैं:
#define MAX_SIZE 20इसके बजाय:
const int MAX_SIZE = 20;
| A) | हां, यह काम करेगा और C++ में कॉन्सटेंट के लिए #define का इस्तेमाल करें |
| B) | हां, यह काम करेगा, लेकिन हम आम तौर पर C++ में कॉन्सटेंट के लिए #define का इस्तेमाल नहीं करते |
| C) | C++ में #define उपलब्ध नहीं है |
| ड) | आप C में इनमें से कोई भी काम नहीं कर सकते |
पांचवां सवाल: typedef का इस्तेमाल किसी टाइप के नाम के लिए उपनाम बनाने के लिए किया जाता है.
| A) | सही. |
| B) | गलत. |
छठा सवाल: अगर हम Fill() फ़ंक्शन में, अरे को 0 से शुरू न करें, तो क्या होगा?
| A) | यह चलेगा, लेकिन आउटपुट सिर्फ़ 12 सेकंड का होगा |
| B) | यह ठीक से चलेगा और वही आउटपुट जनरेट करेगा जैसे कि ऐरे को 0 से शुरू किया गया था |
| C) | प्रोग्राम नहीं चलेगा या क्रैश हो जाएगा |
| ड) | यह चलेगा, लेकिन आउटपुट 0 का होगा |
| E) | यह चलेगा, लेकिन हो सकता है कि कोई आउटपुट जनरेट न करे |
सातवां सवाल: लागू होने वाले सभी विकल्प चुनें. हम इस प्रोग्राम में MAX_SIZE के लिए कॉन्सट का इस्तेमाल क्यों करते हैं? क्या ज़रूरत पड़ने पर, MAX_SIZE की जगह सिर्फ़ "20" टाइप करना आसान नहीं है?
| A) | MAX_SIZE पहले से मौजूद C++ वैल्यू है. इसे कोई भी इस्तेमाल कर सकता है. बस इसे सेट करें और इसका इस्तेमाल करें. |
| B) | ग्लोबल वैरिएबल की तरह ही ग्लोबल कॉन्स से भी बचना चाहिए |
| C) | कॉन्स्ट का इस्तेमाल करने से, हमारे प्रोग्राम को समझने में आसानी होती है |
| ड) | किसी प्रोग्राम में मौजूद मैजिक नंबर को आम तौर पर अच्छा तरीका माना जाता है. |
| E) | अगर हम MAX_SIZE बदलना चाहते हैं, तो हमें इसे केवल एक ही जगह पर बदलना होगा |
सवाल 8: भरें() फ़ंक्शन में स्विच स्टेटमेंट का डिफ़ॉल्ट केस होना चाहिए, क्योंकि एक अच्छा स्टाइल माना जाता है.
| A) | सही. |
| B) | गलत. |
नौवां सवाल: fill() फ़ंक्शन में, हम स्टेटमेंट के बीच में वैरिएबल तय करते हैं. उदाहरण के लिए, फ़ॉर-लूप चलने के बाद cNum और cRow को एलान और शुरू किया जाता है. क्या यह C++ में काम करेगा या सभी वैरिएबल को फ़ंक्शन के सबसे ऊपर तय करना होगा?
| A) | ऐसा करना ठीक है. |
| B) | सभी वैरिएबल, फ़ंक्शन के सबसे ऊपर मौजूद होने चाहिए. |
| C) | दोनों तरीके गलत हैं - C++ प्रोग्राम में कहीं भी वैरिएबल को इस्तेमाल करने की अनुमति नहीं देता. |
| ड) | सभी वैरिएबल, ग्लोबल स्कोप में तय किए जाने चाहिए. |
सवाल का सेट 4
यहां सामान्य क्लास को परिभाषित करने और उसकी जांच करने वाली फ़ाइलों का सेट दिया गया है. हमेशा की तरह, सिर्फ़ सोर्स कोड की मदद से ही आने वाले सवालों के जवाब दें.
हेडर फ़ाइल (cow.h) यहां दी गई है:
#ifndef COW_H
#define COW_H
using namespace std;
typedef enum Color {black, brown, beige, blackandwhite, nocolor};
class Cow {
public:
Cow();
~Cow();
// accessors
double weight() { return weight_; };
string name() { return name_; };
Color color() { return color_; };
// mutators
void set_name(string inName) { name_ = inName; };
void set_color(Color inColor) { color_ = inColor; };
void set_weight(double inWeight) {weight_ = inWeight; };
void Moo();
void Properties();
private:
Color color_;
double weight_;
string name_;
};
#endif
यह रही इससे जुड़ी .cc फ़ाइल (cow.cc):
#include <iostream>
#include "cow.h"
using namespace std;
Cow::Cow() {}
Cow::~Cow() {}
void Cow::Moo() {
cout << name() << " says MOO." << endl;
}
void Cow::Properties() {
cout << name() << " weighs " << weight() << ", is "
<< color() << " and says MOO." << endl;
}
और यहां इस क्लास के लिए एक क्लाइंट प्रोग्राम दिया गया है (cowmain.cc):
#include <iostream>
#include "cow.h"
using namespace std;
int main() {
Cow cow1;
cow1.set_name("betsy");
cow1.set_weight(400.0);
cow1.set_color(black);
cow1.Moo();
cow1.Properties();
}
पहला सवाल: इस प्रोग्राम से क्या फ़ायदा होता है?
| A) | बटी कहती हैं कि MOO. बबीता का वज़न 400 है और यह 0 है और बताता है कि MOO. |
| B) | बटी कहती हैं कि MOO. बेस्टी का वज़न 400 है, जो काले रंग की है और लिखा है MOO. |
| C) | बटी कहती हैं कि MOO. बेस्टी का वज़न 400 है, वह है |
दूसरा सवाल: हमें ऐक्सेसर और म्यूटेटर के तरीकों का कोड, हेडर फ़ाइल में कभी नहीं रखना चाहिए. (ध्यान दें कि ऐक्सेसर, वैल्यू दिखाने वाला तरीका है. वहीं, म्यूटेटर एक ऐसा तरीका है जिससे वैल्यू में बदलाव किया जाता है.)
| A) | सही. |
| B) | गलत. |
तीसरा सवाल: क्या हमें cow.cc में फ़ंक्शन की हर परिभाषा से पहले "Cow::" की ज़रूरत है?
| A) | नहीं - क्योंकि cow.h शामिल है |
| B) | हां |
चौथा सवाल: खाते की क्या भूमिका है:
#ifndef COW_H #define COW_H ... #endif
हेडर फ़ाइल में कैसे चलाना है?
लागू होने वाले सभी विकल्प चुनें:
| A) | वे किसी मकसद के लिए काम नहीं करते, क्योंकि फ़ाइल का नाम cow.h है, न कि COW_H. |
| B) | अगर हम ऐसा नहीं करेंगे, तो हमें रनटाइम की गड़बड़ी मिलेगी |
| C) | अगर हम ऐसा नहीं करते हैं, तो हम फ़ाइल को एक से ज़्यादा बार शामिल कर सकते हैं |
| ड) | वे कुछ नहीं करती, क्योंकि एक या ज़्यादा कीवर्ड की स्पेलिंग गलत है. |
| E) | वे कुछ नहीं करते, क्योंकि Cow क्लास में सिर्फ़ एक हेडर फ़ाइल है. |
पांचवां सवाल: अगर हम cowmain.cc में यह लाइन जोड़ते हैं, तो क्या होगा?
cow1.weight_ = 24;
| A) | प्रोग्राम चलता रहेगा और वेट वैरिएबल में इस लाइन से बदलाव किया जाएगा. |
| B) | प्रोग्राम कंपाइल करेगा और चलेगा, लेकिन उस लाइन पर क्रैश हो जाएगा. |
| C) | C++ इसकी अनुमति नहीं देता. |
| ड) | प्रोग्राम को कंपाइल करके चलाया जाएगा, लेकिन इस लाइन से वेट के वैरिएबल में कोई बदलाव नहीं होगा. |
सवाल 6: जब नीचे दी गई लाइन चलाई जाती है, तो Cow क्लास के कंस्ट्रक्टर को कॉल किया जाता है:
Cow cow1;
कंस्ट्रक्टर की कुछ अहम विशेषताएं क्या हैं?
लागू होने वाले सभी विकल्प चुनें
| A) | आम तौर पर, वे कोई वैल्यू नहीं दिखाते |
| B) | अगर हम अपनी क्लास में कंस्ट्रक्टर नहीं देते हैं, तो क्लास कंपाइल नहीं करेगी |
| C) | Cow क्लास में कंस्ट्रक्टर असामान्य है, क्योंकि यह प्राइवेट वैरिएबल को शुरू नहीं करता. |
| ड) | उनका नाम हमेशा वही होता है जो क्लास का है |
| E) | अगर सभी तर्क अलग-अलग हैं, तो क्लास में कई कंस्ट्रक्टर हो सकते हैं |
| शु) | कंस्ट्रक्टर को तब ट्रिगर किया जाता है, जब किसी क्लास को शुरू किया गया हो. |
सवाल 7: विनाशक के कुछ अहम लक्षण क्या हैं?
| A) | जब कोई ऑब्जेक्ट दायरे से बाहर हो जाता है, तब डिस्ट्रक्टर को कॉल किया जाता है |
| B) | विध्वंसक का नाम क्लास जैसा ही होता है, लेकिन इससे पहले "~" होता है |
| C) | cow.cc के डेटा को नष्ट करने वाले टूल में कुछ गड़बड़ी है, क्योंकि यह कुछ नहीं करता. |
| ड) | अगर हम अपनी क्लास के लिए नुकसान पहुंचाने वाला कोई डेटा नहीं बनाते, तो क्लास कंपाइल नहीं करेगी |
आठवां सवाल: क्लाइंट प्रोग्राम, क्लास का इस्तेमाल जिस तरह से कर रहा है, उसे देखते हुए इन बातों पर ध्यान दें:
गाय की क्लास में, सदस्यों को सार्वजनिक और निजी में बांटना सही नहीं है. इसका मतलब है कि जो चीज़ निजी है, वह सार्वजनिक होनी चाहिए या जो सार्वजनिक है, वह निजी होनी चाहिए.
| A) | सही. |
| B) | गलत. |
सवाल 9: क्या होगा अगर हमने cow.cc के अलावा कोई और कंस्ट्रक्टर जोड़ दिया हो. नया कंस्ट्रक्टर ऐसा दिखता है
Cow::Cow(string inName, double inWeight, Color inColor) {
set_name(inName);
set_weight(inWeight);
set_color(inColor);
}
और हम इन पंक्तियों को मुख्य() में जोड़ते हैं:
Cow cow2("milly", 350.2, brown);
cow2.Moo();
cow2.Properties();
क्या हम ऐसा कर सकते हैं?
लागू होने वाले सभी विकल्प चुनें
| A) | men() की वह लाइन जहां हम cow2 शुरू करते हैं, क्रैश हो जाएगी. |
| B) | हमारे पास सिर्फ़ एक कंस्ट्रक्टर हो सकता है. |
| C) | यह C++ में सामान्य है |
| ड) | हां, लेकिन यह C++ का सामान्य इस्तेमाल नहीं है |
| E) | यह ठीक रहेगा, लेकिन इससे कुछ भी आउटपुट नहीं होगा, क्योंकि 'निजी' चालू नहीं हैं. |
| शु) | हम एक ही क्लास के किसी तरीके में setName(), setColor() और setWeight() को कॉल नहीं कर सकते. |
बोनस सवाल
पहला सवाल) यहां दी गई जानकारी से क्या नतीजा निकला?
#include <iostream>
using namespace std;
void HelpMe(int *p, int *num, int *q);
void WhereAmI(int *p, int *q, int a);
void HelpMe(int *p, int *num, int *q) {
int a;
a = 2;
q = &a;
*p = *q + *num;
num = p;
}
void WhereAmI(int *p, int *q, int a) {
a = 6;
*p = a + *p;
*q = a + 3;
HelpMe(q, &a, p);
}
int main() {
int *p;
int q;
int *num;
int a;
a = 3;
q = 5;
p = &a;
num = &q;
HelpMe(&a, p, num);
WhereAmI(&q, p, *num);
cout << "*p = " << *p << " q = " << q << " *num = " << *num << endl;
}
दूसरा सवाल) यह मानते हुए कि Apple क्लास मौजूद है और उसे शुरू कर दिया गया है, इस स्टेटमेंट पर विचार करें. Apple क्लास में एक color_ इंस्टेंस वैरिएबल है:
Apple* granny_smith = new Apple;
नीचे दिए गए उन सभी स्टेटमेंट को चुनें जो सही हैं:
| A) | Apple* granny_smith = NULL; अगर (granny_smith == NULL)... यह ठीक नहीं है - NULL कोई ऐसी वैल्यू नहीं है जिसकी जांच इस तरह से की जा सके. |
| B) | Apple* granny_smith, fuji; यह Apple ऑब्जेक्ट के दो पॉइंटर के बारे में बताता है |
| C) | granny_smith वैरिएबल में Apple ऑब्जेक्ट से जुड़े इंस्टेंस वैरिएबल की वैल्यू शामिल होंगी |
| ड) | Apple* granny_smith = NULL; यह ठीक है, |
| E) | granny_smith वैरिएबल में Apple ऑब्जेक्ट का पता शामिल होता है |
| शु) | स्ट्रिंग gs_color = *(granny_smith.get_color()); यह मानते हुए कि यह इनीशियलाइज़ कर दिया गया है, यह स्टेटमेंट granny_smith ऑब्जेक्ट का रंग दिखाता है. |
| ग) | नए Apple ऑब्जेक्ट के लिए स्टोरेज को हीप में बांटा गया है |
| हर) | नए Apple ऑब्जेक्ट के लिए स्टोरेज को रनटाइम स्टैक में बांटा गया है |
| I) | int* a = &b; यह b का पता a में रखता है. |
सवाल 3) इस प्रोग्राम का आउटपुट क्या है?
#include <iostream>
using namespace std;
const int kNumVeggies = 4;
void Grill(int squash, int *mushroom);
int Saute(int onions[], int celery);
void Grill(int squash, int *mushroom) {
*mushroom = squash/4;
cout << *mushroom + squash << endl;
}
int Saute(int onions[], int celery) {
celery *= 2;
onions[celery]++;
Grill(onions[0], &onions[3]);
cout << celery << " " << onions[3] << endl;
return celery;
}
int main() {
int broccoli, peppers[kNumVeggies], *zucchini;
for (broccoli = 0; broccoli < kNumVeggies; broccoli++)
peppers[broccoli] = kNumVeggies - broccoli;
zucchini = &peppers[Saute(peppers,1)];
Grill(*zucchini, zucchini);
zucchini--;
cout << peppers[3] + *zucchini + *(zucchini + 1) << endl;
}
क्विज़ के जवाब
आपको ऊपर दिए गए सभी सवालों के जवाब देखने की कोशिश नहीं करनी चाहिए. सीधे जवाब वाली शीट पर जाने के बजाय, किसी से मदद मांगें.
ऊपर बताई गई समस्याओं के जवाब यहां देखे जा सकते हैं.