सवाल सेट 1
यहां दिए गए प्रोग्राम को पढ़ें और फिर इन सवालों के जवाब दें. हम चाहते हैं कि आप सिर्फ़ सोर्स कोड को देखकर सवालों के जवाब दें, यानी कि कृपया इसे किसी फ़ाइल में कॉपी न करें, उसे कंपाइल करके सवालों के जवाब दें. यह तो बहुत मज़ा आएगा!
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 |
| ब) |
1 1 2 4 1 1 2 4 1 1 2 4 |
| स) |
1 1 2 4 1 1 2 4 1 1 |
| द) |
1 1 2 4 1 1 1 1 2 4 |
| E) | यह कोई आउटपुट नहीं देता - सिंटैक्स में गड़बड़ियां हैं. |
दूसरा सवाल: "काउंटर" की शुरुआत करने पर क्या होगा के पहले क्या करना है?
| A) | इनफ़ाइनाइट लूप - 'डू-टाइम लूप', '1's की सीरीज़ बनाता है |
| ब) | प्रोग्राम के आउटपुट में कोई बदलाव नहीं होगा |
| स) | 'डू-टाइम लूप', आउटपुट के तौर पर 2 और 4 देता है. |
| द) | 'डू-बीज़' लूप में, कोई आउटपुट नहीं मिलेगा |
| E) | 'डू-टाइम लूप', आउटपुट के तौर पर 3 और 9 देता है. |
तीसरा सवाल: इस पेज में सबसे ऊपर दिए गए ओरिजनल प्रोग्राम को देखते हुए, मान लें कि हमारे पास लूप के दौरान, काउंटर वैरिएबल को शुरू करने वाली लाइन को हटाया गया. क्या फ़ायदे दें ऐसा तब होगा, जब हम लूप में मौजूद काउंटर++ लाइन को भी हटा देंगे, जैसा कि हैं?
| A) | जबकि लूप से कुछ नहीं मिलता. |
| ब) | जबकि लूप, 1 और 1 देता है; 'क्या करें' लूप में कुछ भी आउटपुट नहीं होता. |
| स) | लूप की दोनों लाइनों का आउटपुट एक जैसा होता है शामिल हैं. |
| द) | जब तक हम कंप्यूटर को चालू नहीं करते, तब तक सिस्टम किसी भी क्रम में बंद करें. |
| E) | जबकि लूप एक अनंत लूप है |
चौथा सवाल: इस पेज में सबसे ऊपर दिए गए ओरिजनल प्रोग्राम को देखते हुए, क्या होगा क्या लूप ऐसा दिखता था?
counter = first;
while (counter <= last) {
cout << "\n" << counter;
if (first % 2 == 0)
next = counter * counter;
cout << " " << next;
counter++;
}| A) | जबकि लूप का आउटपुट मूल प्रोग्राम जैसा ही होता है. |
| ब) | जबकि लूप से कुछ भी आउटपुट नहीं मिलेगा |
| स) | लूप के लूप का आउटपुट 1 1 और 1 4 है. |
| द) | जबकि लूप का आउटपुट 1 2 और 2 4 है. |
| E) | जबकि लूप का आउटपुट 1 4 और 2 4 है. |
| म॰ | जबकि लूप का आउटपुट 2 4 और 2 4 है. |
सवाल 5: अगर पहला वैरिएबल पिछले वैरिएबल से बड़ा हो, तो क्या होगा?
| A) | जबकि-लूप से कुछ आउटपुट मिलेगा, लेकिन कुछ भी नहीं. |
| ब) | ' लूप के दौरान लूप में चलाएं' का इस्तेमाल करने से कुछ आउटपुट मिलेगा, लेकिन कुछ और नहीं मिलेगा. |
| स) | कोई आउटपुट नहीं मिलेगा. |
| द) | प्रोग्राम, गड़बड़ी या क्रैश हो जाएगा |
| E) | फॉर-लूप से कुछ आउटपुट मिलेगा, लेकिन कोई और नहीं मिलेगा. |
छठा सवाल: अगर हम पहला वैरिएबल शुरू करते हैं, तो प्रोग्राम से मिलने वाला आउटपुट क्या होगा आखिरी वैरिएबल के जैसा हो?
| A) | ' लूप के दौरान लूप में चलाएं' का इस्तेमाल करने से कुछ आउटपुट मिलेगा, लेकिन कुछ और नहीं मिलेगा. |
| ब) | जबकि-लूप से कुछ आउटपुट मिलेगा, लेकिन कुछ भी नहीं. |
| स) | हर लूप से एक लाइन जनरेट होगी. |
| द) | लूप के दौरान दो लाइनें और दूसरी लाइन को लूप में चलाएं. |
| 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;
}पहला सवाल: मार्क की गई लाइनों पर Boys वैरिएबल का आउटपुट क्या है?
| A) |
#1: 6 #2: 3 #3: 11 #4: 11 |
| ब) |
#1: 6 #2: 3 #3: 11 #4: 3 |
| स) |
#1: 6 #2: 6 #3: 11 #4: 11 |
| द) | यह कुछ भी आउटपुट नहीं करता, क्योंकि यह न तो कंपाइल करता है और न ही चलता है. |
दूसरा सवाल: प्रोग्राम की इन लाइनों में लागू होने वाले सभी विकल्प चुनें:
void F1(int males, int females); void F2(int &m, int &f);
| A) | C++ के नियमों में बताया गया है कि हम इन दो लाइनों को तब तक हटा सकते हैं, जब तक तरीके इस्तेमाल करने से पहले उनके बारे में बताया जाता है. |
| ब) | C++ के नियमों में बताया गया है कि आर्ग्युमेंट के नाम दोनों के बीच एक जैसे होने चाहिए एलान और परिभाषा. |
| स) | अगर हम इन दो पंक्तियों को हटा देते हैं, तो यह प्रोग्राम क्रैश हो जाएगा. |
| द) | एलानों को दुनिया भर में आम तौर पर इस्तेमाल किया जाता है दायरा. |
| E) | इन्हें फ़ॉरवर्ड एलान कहा जाता है. |
तीसरा सवाल: अगर हम नीचे दी गई लाइन को Main() से ले जाते हैं और उसे ग्लोबल तो क्या होगा?
int Boys = 3, Girls = 5;
| A) | आउटपुट समान ही रहेगा. |
| ब) | सभी आउटपुट में लड़कों का = 3 होगा और लड़कियों का = 5 होगा |
| स) | लड़कों का नाम = 3 होगा और लड़कियां सिर्फ़ Main() से मिलने वाले आउटपुट में = 5 करेंगी |
सवाल 4: अगर हम प्रोग्राम की शुरुआत में ही इस तरह से बदलाव करें, तो क्या होगा:
// We have moved moved these to global scope
const int Boys = 3;
const int Girls = 5;
void main() {
//int Boys = 3, Girls = 5;| A) | प्रोग्राम कंपाइल हो जाएगा, लेकिन जब हम उसे चलाने की कोशिश करेंगे, तो वह क्रैश हो जाएगा. |
| ब) | आउटपुट में कोई बदलाव नहीं होगा |
| स) | पूरे प्रोग्राम के लिए आउटपुट में लड़के = 3 लड़कियां = 5 होगा |
| द) | आउटपुट में लड़के = 3 लड़कियां = 5 सिर्फ़ Main() से मिलने वाले आउटपुट में होंगे |
| E) | कंपाइलर के आधार पर, शायद प्रोग्राम कंपाइल नहीं होगा. |
पांचवां सवाल: F2 में डेटा को वैल्यू के हिसाब से पास किया जाता है.
| A) | सही. |
| ब) | गलत. |
सवाल सेट 3
जैसा कि आपने पिछले सवाल में किया था, यहां आपकी राय के लिए एक प्रोग्राम दिया गया है. प्लीज़ सिर्फ़ सोर्स कोड को देखकर पूछे जाने वाले सवालों के जवाब दें.यह है पिछले दो विकल्पों से ज़्यादा दिलचस्प है - कोड को ध्यान से ट्रेस करें.
#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;
}
}पहला सवाल: यह प्रोग्राम, लाइन के लिए तीन और लाइन के लिए 4 के इनपुट के साथ क्या जनरेट करता है कॉलम?
| A) |
1 2 3 4 5 6 7 8 9 10 11 12 |
| ब) |
1 2 3 4 5 6 7 8 9 10 11 12 |
| स) |
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 |
| घ) | यह कुछ भी आउटपुट नहीं करता - तर्क गलत है. |
| मैं) | इससे कोई आउटपुट नहीं मिलता - सिंटैक्स से जुड़ी गड़बड़ियां हैं. |
| J) | इसकी वजह से कोई नतीजा नहीं मिलता - ऐसा करना ज़रूरी नहीं है. |
| के) | प्रोग्राम के शुरू होने का इंतज़ार करते समय, सबसे पहले 12 नंबर आपके दिमाग में आते हैं. |
दूसरा सवाल: अगर हम यह लाइन अपने Main() फ़ंक्शन में जोड़ते हैं, तो क्या होगा?
MAX_SIZE = 10;
| A) | C++ में इसकी अनुमति नहीं है. |
| ब) | ऐसा करने की अनुमति है; प्रोग्राम MAX_SIZE पर सेट होने पर 20 पर चलेगा |
| स) | ऐसा करने की अनुमति है; तो प्रोग्राम MAX_SIZE पर सेट करके 10 पर चलेगा. |
तीसरा सवाल: ऊपर दिए गए प्रोग्राम की इन चार लाइनों पर ध्यान दें:
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) हां |
| ब) | 1) नहीं 2) नहीं |
| स) | 1) नहीं 2) हां |
| द) | 1) हां 2) नहीं |
चौथा सवाल: क्या हम इनका इस्तेमाल कर सकते हैं:
#define MAX_SIZE 20
const int MAX_SIZE = 20;
| A) | हां, यह काम करेगा और इसमें स्थिरांक के लिए # मिलते-जुलते फ़ंक्शन का इस्तेमाल करना ठीक है C++ |
| ब) | हां, यह काम करेगा, लेकिन आम तौर पर हम कॉन्सटेंट के लिए #फ़ंक्शन का इस्तेमाल नहीं करते हैं C++ में |
| स) | #परिभाषा C++ में उपलब्ध नहीं है |
| द) | आप C में इनमें से कोई भी काम नहीं कर सकते |
सवाल 5: typedef का इस्तेमाल किसी प्रकार के नाम के लिए उपनाम बनाने के लिए किया जाता है.
| A) | सही. |
| ब) | गलत. |
सवाल 6: अगर हम अरे को शुरू में 0 पर सेट नहीं करते हैं, तो क्या होगा भरें() फ़ंक्शन?
| A) | यह चलेगा, लेकिन आउटपुट वाला 12 सेकंड का होगा |
| ब) | यह ठीक से काम करेगा और वैसा ही आउटपुट जनरेट करेगा, जैसा कि अरे 0 से शुरू किया गया |
| स) | प्रोग्राम नहीं चलेगा या क्रैश हो जाएगा |
| द) | यह चलेगा, लेकिन आउटपुट शून्य सेकंड होगा |
| E) | यह चलेगा, लेकिन हो सकता है कि कोई आउटपुट जनरेट न करे |
सातवां सवाल: लागू होने वाले सभी विकल्प चुनें. हम इस प्रोग्राम में MAX_SIZE के लिए Const का इस्तेमाल क्यों करते हैं? क्या सिर्फ़ "20" टाइप करना आसान नहीं है MAX_SIZE के बजाय यह जहां भी हो क्या ज़रूरत है?
| A) | MAX_SIZE पहले से मौजूद C++ वैल्यू है. इसका इस्तेमाल कोई भी कर सकता है. अभी-अभी सेट अप किया गया और उसका इस्तेमाल करें. |
| ब) | ग्लोबल वैरिएबल की तरह ही ग्लोबल कॉन्स्ट भी शामिल नहीं होने चाहिए |
| स) | कॉन्स्ट का इस्तेमाल करने से, हमारे प्रोग्राम को समझने में आसानी होती है |
| द) | आम तौर पर, किसी प्रोग्राम में जादू के आंकड़ों को सही तरीका माना जाता है. |
| E) | अगर हम MAX_SIZE को बदलना चाहते हैं, तो हमें इसे केवल एक में बदलना होगा जगह |
सवाल 8: Fill() फ़ंक्शन में स्विच स्टेटमेंट का डिफ़ॉल्ट होना चाहिए केस, क्योंकि किसी एक को शामिल करना एक अच्छी स्टाइल माना जाता है.
| A) | सही. |
| ब) | गलत. |
सवाल 9: Fill() फ़ंक्शन में, हम स्टेटमेंट के बीच वैरिएबल का एलान करते हैं. उदाहरण के लिए, cNum और cRow का एलान किया जाता है और फ़ॉर-लूप चलने के बाद उसे शुरू किया जाता है. क्या यह C++ में काम करेगा या सभी वैरिएबल को सबसे ऊपर फ़ंक्शन?
| A) | ऐसा करना ठीक है. |
| ब) | सभी वैरिएबल का एलान, फ़ंक्शन के सबसे ऊपर किया जाना चाहिए. |
| स) | दोनों तरीके गलत हैं - 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 कह रहे हैं. |
| ब) | बैटी कहती हैं कि MOO. अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है बेट्सी का वज़न 400 है, वह काले रंग का है और MOO कह रही है. |
| स) | बैटी कहती हैं कि MOO. अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है बेट्सी का वज़न 400 है, |
दूसरा सवाल: हमें ऐक्सेसर और म्यूटेटर के तरीकों के लिए कभी भी कोड नहीं डालना चाहिए हेडर फ़ाइल में. (ध्यान दें कि ऐक्सेसर ऐसा तरीका है जो वैल्यू और म्यूटेटर दिखाता है वैल्यू को बदलने का तरीका है.)
| A) | सही. |
| ब) | गलत. |
सवाल 3: क्या हमें "काउ::" की ज़रूरत है हर फ़ंक्शन की परिभाषा से पहले cow.cc में है?
| A) | नहीं - क्योंकि cow.h शामिल है |
| ब) | हां |
चौथा सवाल: क्या भूमिका निभानी है:
#ifndef COW_H #define COW_H ... #endif
हेडर फ़ाइल में चलाना है?
लागू होने वाले सभी विकल्प चुनें:
| A) | फ़ाइल का नाम cow.h है. इसलिए, ये किसी काम के लिए इस्तेमाल नहीं किए जाते COW_H नहीं. |
| ब) | अगर हमने ऐसा नहीं किया, तो हमें रनटाइम से जुड़ी गड़बड़ी मिलेगी |
| स) | अगर हमने ऐसा नहीं किया, तो हम फ़ाइल को एक से ज़्यादा बार शामिल कर सकते हैं |
| द) | वे कुछ नहीं करते, क्योंकि एक या उससे ज़्यादा कीवर्ड की स्पेलिंग गलत है. |
| E) | वे कुछ नहीं करते, क्योंकि गाय क्लास के पास सिर्फ़ एक हेडर फ़ाइल होती है. |
पांचवां सवाल: अगर हम यह लाइन cowmain.cc में जोड़ दें, तो क्या होगा?
cow1.weight_ = 24;
| A) | प्रोग्राम चलेगा और वेट वैरिएबल बदल जाएगा इस लाइन से. |
| ब) | प्रोग्राम कंपाइल किया जाएगा और चलेगा, लेकिन उस लाइन पर क्रैश हो जाएगा. |
| स) | C++ में इसकी अनुमति नहीं है. |
| द) | प्रोग्राम कंपाइल और रन करेगा, लेकिन वेट वैरिएबल नहीं है इस लाइन से बदला गया. |
छठा सवाल: नीचे दी गई लाइन एक्ज़ीक्यूट होने पर, गाय क्लास के कंस्ट्रक्टर को कॉल किया जाता है:
Cow cow1;
कंस्ट्रक्टर की कुछ खास विशेषताएं क्या हैं?
लागू होने वाले सभी विकल्प चुनें
| A) | आम तौर पर, इनसे कोई वैल्यू नहीं मिलती है |
| ब) | अगर हम अपनी क्लास में कोई कंस्ट्रक्टर उपलब्ध नहीं कराते हैं, तो क्लास कंपाइल नहीं किया गया |
| स) | Cow क्लास का कंस्ट्रक्टर असामान्य है, क्योंकि यह शुरू नहीं होता है प्राइवेट वैरिएबल का इस्तेमाल कर सकते हैं. |
| द) | उनका नाम हमेशा क्लास जैसा ही होता है |
| E) | जब तक तर्क हो, तब तक एक क्लास में कई कंस्ट्रक्टर हो सकते हैं अलग करें |
| म॰ | जब क्लास शुरू की जाती है, तो कंस्ट्रक्टर का इस्तेमाल किया जाता है. |
सातवां सवाल: किसी विनाश करने वाले की कुछ खास विशेषताएं क्या हैं?
| A) | जब कोई ऑब्जेक्ट दायरे से बाहर हो जाता है, तो विनाशकर्ता कॉल किया जाता है |
| ब) | डिस्ट्रक्टर का नाम क्लास के नाम जैसा ही होता है, लेकिन इससे पहले "~" होता है |
| स) | cow.cc की मदद से नुकसान पहुंचाने वाले डिवाइस में कुछ गड़बड़ी है कुछ नहीं करता. |
| द) | अगर हम अपनी क्लास के लिए कोई डिस्ट्रक्टर नहीं बनाते हैं, तो क्लास कंपाइल करें |
सवाल 8: क्लाइंट प्रोग्राम, क्लास का इस्तेमाल जिस तरह से कर रहा है उसे देखते हुए, फ़ॉलो किया जा रहा है:
गाय वर्ग में सदस्यों को सार्वजनिक और निजी में बांटना सही नहीं है. यानी, ऐसी चीज़ जो निजी है, उसे सार्वजनिक होना चाहिए या जो सार्वजनिक है, उसे निजी होना चाहिए.
| A) | सही. |
| ब) | गलत. |
नौवां सवाल: क्या होगा अगर हमने हमें cow.cc की ज़रूरत है. नया कंस्ट्रक्टर ऐसा दिखेगा
Cow::Cow(string inName, double inWeight, Color inColor) {
set_name(inName);
set_weight(inWeight);
set_color(inColor);
}साथ ही, हम इन लाइनों को Main() में जोड़ते हैं:
Cow cow2("milly", 350.2, brown);
cow2.Moo();
cow2.Properties();क्या हम ऐसा कर सकते हैं?
लागू होने वाले सभी विकल्प चुनें
| A) | Main() की वह लाइन क्रैश हो जाएगी जिसमें हम cow2 को शुरू करते हैं. |
| ब) | हमारे पास सिर्फ़ एक कंस्ट्रक्टर हो सकता है. |
| स) | यह 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; if (granny_smith == NULL)... यह ठीक नहीं है - शून्य ऐसी वैल्यू नहीं है जिसकी इस तरीके से जांच की जा सके. |
| ब) | सेब* granny_smith, फ़ूजी; यह Apple ऑब्जेक्ट के लिए दो पॉइंटर बताता है |
| स) | granny_smith वैरिएबल में किसी Apple ऑब्जेक्ट से जुड़े इंस्टेंस वैरिएबल की वैल्यू शामिल होती हैं |
| द) | Apple* granny_smith = NULL; ठीक है, |
| E) | granny_smith वैरिएबल में Apple ऑब्जेक्ट का पता शामिल होता है |
| म॰ | स्ट्रिंग gs_color = *(granny_smith.get_color()); यह स्टेटमेंट, granny_smith ऑब्जेक्ट का रंग लौटाता है, यह मानते हुए कि यह शुरू किया गया है. |
| जी) | नए Apple ऑब्जेक्ट के लिए स्टोरेज को हीप में बांटा गया है |
| घ) | नए Apple ऑब्जेक्ट के लिए स्टोरेज, रनटाइम स्टैक में असाइन किया जाता है |
| मैं) | int* a = &b; यह b के पते को a. |
तीसरा सवाल) इस प्रोग्राम का आउटपुट क्या है?
#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;
}
क्विज़ के जवाब
आपको ऊपर दिए गए सभी सवालों के जवाब बिना देखे पूरा करने की कोशिश करनी चाहिए. सहायता के लिए सीधे जवाब शीट पर जाने के बजाय किसी से मदद मांगना बेहतर है.
ऊपर बताई गई समस्याओं के जवाब यहां देखे जा सकते हैं.