मुख्य() फ़ंक्शन

Question

#include<iostream.h> 
void main() 
{ 
    cout<<"Love"; 
} 

सवाल बदले बिना सी ++ उत्पादन बदलने कैसे हम में इस कार्यक्रम का उत्पादन बदल सकते हैं main() में कोई बदलाव किए बिना "आई लव यू" है।

Answer 1

आपको किसी अन्य फ़ंक्शन को कॉल करके या टेक्स्ट को बदलकर मुख्य को बदलने की आवश्यकता है। चूंकि main() आपके प्रोग्राम का मुख्य आउटपुट

Answer 2

क्या आप थोड़ा और सटीक हो सकते हैं?

क्या आप कोड के उस टुकड़े का उत्पादन "प्यार" के बजाय "मैं तुमसे प्यार करता हूं" होना चाहता हूं?

संपादित करें: मुझे नहीं लगता कि आप मुख्य() में कोड की कम से कम एक पंक्ति को बदलने के बिना नहीं कर सकते हैं। आप या तो < < < < "प्यार" से "प्यार" को बदल सकते हैं "मैं तुमसे प्यार करता हूं" या बस उस विशिष्ट पंक्ति को आउटपुट करने वाला एक फ़ंक्शन जोड़ें।

Answer 3

क्या आपका मुख्य कार्य एक int वापस नहीं करना चाहिए? आपको या तो विधि को बदलने की आवश्यकता होगी, या एक और प्रोग्राम लिखना होगा जिसमें यह एक पाइप हो, लेकिन यह एक साधारण स्ट्रिंग को बदलने के तरीके के बारे में सबसे अधिक गोल है ...

Answer 4

उस कोड में std का उपयोग नहीं किया गया है लेकिन वैसे भी काउंटर के चारों ओर अपने स्वयं के रैपर को लिखने और उपयोग करने वाले std को हटाने की आवश्यकता होगी यदि रैपर परिभाषित किया गया है जहां mystd का उपयोग करने के साथ वहां था।

Answer 5

मुझे लगता है कि आप एक ऑपरेटर < < लिख सकते हैं जो वर्तमान आउटपुट के बाद "मैं" और "आप" जोड़ता है।

Answer 6

ठीक है, अपने मुख्य कार्य और iostream.h फिक्सिंग ... इस तरह

#include <iostream> 

// to make sure std::cout is constructed when we use it 
// before main was called - thxx to @chappar 
std::ios_base::Init stream_initializer; 

struct caller { 
    caller() { std::cout << "I "; } 
    ~caller() { std::cout << " You"; } 
} c; 

// ohh well, for the br0ken main function 
using std::cout; 

int main() 
{ 
    cout<<"Love"; 
} 

मैं सोचा मैं क्यों कि काम करता है समझाने चाहिए। कोड एक संरचना को परिभाषित करता है जिसमें एक निर्माता और विनाशक होता है। जब आप संरचना का ऑब्जेक्ट बनाते हैं तो कन्स्ट्रक्टर चलाया जाता है और जब ऑब्जेक्ट नष्ट हो जाता है तो विनाशक चलाया जाता है। अब, एक संरचना परिभाषा के अंत में, आप घोषणाकर्ताओं को डाल सकते हैं जिनके प्रकार caller होगा।

तो, हमने ऊपर जो किया है वह c नामक ऑब्जेक्ट बना रहा है जिसे प्रोग्राम शुरू होने पर बनाया गया है (और कन्स्ट्रक्टर कहा जाता है) - मुख्य भाग से पहले भी। और जब कार्यक्रम समाप्त हो जाता है, वस्तु नष्ट हो जाती है और विनाशक चलाया जाता है। बीच में, main मुद्रित "प्यार"।

यह पैटर्न वास्तव में RAII शब्द से बहुत अच्छी तरह से जाना जाता है जो आम तौर पर निर्माता में कुछ संसाधन का दावा करता है और इसे विनाशक कॉल में फिर से जारी करता है।

Answer 7

इस तरह:

#include <iostream> 
int main() { 
    std::cout << "I Love You" << std::endl; 
    return 0; 
} 

/* 
#include<iostream.h> 
void main() 
{ 
    cout<<"Love"; 
} 
*/ 

इस तरह, आप main में कुछ भी नहीं बदला है। :-p

Answer 8

ऐसा लगता है कि आप कह रहे हैं कि आप कोड परिवर्तन नहीं चाहते हैं, लेकिन आप अलग-अलग व्यवहार चाहते हैं।

1. या तो दुरुपयोग पूर्व प्रोसेसर/संकलक, या कोड के रूप में litb के रचनात्मक समाधान में ऊपर देखा: चूंकि व्यवहार आप चाहते हैं जादू के द्वारा प्राप्त नहीं किया जा सकता कि आप दो वास्तविक समाधान है।
2. कोड को संकलित करें ताकि यह "प्यार" प्रिंट हो, लेकिन फिर उत्पन्न बाइनरी को संपादित करें।

मुझे? मैं कॉपी सुरक्षा तोड़ता था इसलिए मैं बाद का मार्ग जाऊंगा। आपके पास मौजूद स्रोत से प्रोग्राम बनाएं लेकिन फिर बाइनरी संपादित करें ताकि यह व्यवहार करे कि आप कैसे पसंद करते हैं।

इस समाधान की चौराहे की प्रकृति को देखते हुए हालांकि मैं दृढ़ता से आपकी प्रेरणा पर आश्चर्यचकित हूं। यह इस तरह के एक व्यर्थ सवाल पूछने के लिए जब तक आप compilers समझ में नहीं आता, या भयावह प्रेरणा है की तरह लगता है ...

Answer 9

#include <iostream> 
class tclass 
{ 
    public: 
    void operator <<(char *s) 
    { 
      std::cout<<"I"<<s<<"You"<<std::endl; 
    } 
}; 

tclass cout; 

int main() 
{ 
    cout<<"love"; 
} 

Answer 10

के रूप में सुंदर नहीं litb के रूप में, लेकिन एक विकल्प:

#include <iostream> 
using namespace std; 

int foo() 
{ 
    cout << "I Love You" << endl; 
    return cout.rdbuf(0); 
} 
int i = foo(); 

int main() 
{ 
    cout << "Love" << endl; 
} 

Answer 11

सबक यह है कि सी ++ स्थिर कन्स्ट्रक्टर/विनाशकों के माध्यम से मुख्य() के पहले और बाद में कोड निष्पादित कर सकता है, उदाहरण के लिए। कोड litb द्वारा पोस्ट किया गया।

Answer 12

litb के रूप में नहीं

के रूप में सुंदर है, लेकिन यह

#include <iostream> 
#include <cstdio> 
#include <sstream> 

#define cout  printf("I love you\n"); std::ostringstream os; os 

int main() 
{ 
    cout << "love"; 
} 

बेशक

काम करता है, तो आप एक stringstream उपयोग करने की आवश्यकता नहीं है, आप operator<< के साथ किसी भी वर्ग इस्तेमाल कर सकते हैं।

Answer 13

मान लीजिए कि यह एक कक्षा असाइनमेंट था, मुझे लगता है कि यह विचार था कि आप iostream.h को फिर से लिख सकते हैं, क्योंकि सी ++ इसे विशेष रूप से (विशेष "की कुछ परिभाषाओं के लिए) नहीं मानता है।

Answer 14

हम यह भी है कि यह कर सकते हैं:

#include <iostream> 
#include <cstdlib> 
using namespace std; 

int fnfoo(int inum){ 
    cout << "I Love You" << endl; 
    return (exit(0),inum); 
} 

int dummy = fnfoo(5); 

int main() 
{ 
    cout << "Love" << endl; 
} 

सरल और पूरी तरह से काम करता है;)

Answer 15

मैं वाकई हैरान कि कोई #define सुझाव दिया "प्यार" "मैं तुमसे प्यार करता हूँ" हूँ ... :)