मैं कन्स्ट्रक्टर में चार सरणी कैसे प्रारंभ कर सकता हूं?

Question

मुझे एक चार सरणी घोषित करने और आरंभ करने में परेशानी हो रही है। यह हमेशा यादृच्छिक पात्र प्रदर्शित करता है। मैं क्या मैं अपने बड़े कार्यक्रम में कोशिश कर रहा हूँ दिखाने के लिए कोड का एक छोटा सा बनाया:

class test 
{ 
    private: 
     char name[40]; 
     int x; 
    public: 
     test(); 
     void display() 
     { 
      std::cout<<name<<std::endl; 
      std::cin>>x; 
     } 
}; 
test::test() 
{ 
    char name [] = "Standard"; 
} 

int main() 
{ test *test1 = new test; 
    test1->display(); 
} 

और खेद अगर मेरे स्वरूपण बुरा है, मैं मुश्किल से बाहर इस वेबसाइट लगा सकते हैं अकेले कैसे मेरे कोड को ठीक करने :(

Answer 1

आप सी ++ का उपयोग कर के बाद से कर रहे हैं, मैं चार सरणियों के बजाय तार का उपयोग कर सुझाव देते हैं। नहीं तो आप strcpy (या मित्र) को रोजगार की जरूरत होगी।

इसके अलावा, आप test1 उदाहरण नष्ट करने के लिए भूल गया था।

#include <iostream> 
#include <string> 

class test 
{ 
    private: 
     std::string name; 
     int x; 
    public: 
     test(); 
     void display() 
     { 
      std::cout<<name<<std::endl; 
     } 
}; 

test::test() 
{ 
    name = "Standard"; 
} 

int main() 
{ 
    test test1; 
    test1.display(); 

    std::cin>>x; 
} 

Answer 2

ध्यान में रखकर आप सी ++ के रूप में प्रश्न में चिह्नित है, तो आप std::string उपयोग करना चाहिए:

#include <string> 

class test 
{ 
    private: 
     std::string name; 
     int x; 
    public: 
     test(); 
     void display() 
     { 
      std::cout<<name<<std::endl; 
      std::cin>>x; 
     } 
}; 
test::test() : name("Standard") 
{ 

} 

Answer 3

आपका निर्माता सदस्य चर name की स्थापना नहीं कर रहा है, यह एक स्थानीय चर घोषित है। एक बार जब स्थानीय परिवर्तक कन्स्ट्रक्टर के अंत में गुंजाइश से बाहर हो जाता है, तो यह गायब हो जाता है। इस बीच सदस्य चर अभी भी शुरू नहीं हुआ है और यादृच्छिक कचरा से भरा है।

यदि आप पुराने फैशन वाले वर्णों का उपयोग करने जा रहे हैं तो आपको सदस्य चर में प्रतिलिपि बनाने के लिए strcpy जैसे पुराने फ़्रेम वाले फ़ंक्शन का उपयोग करने की आवश्यकता होगी। यदि आप बस इतना करना चाहते हैं कि इसे खाली स्ट्रिंग पर सेट करें तो आप इसे name[0] = 0 से प्रारंभ कर सकते हैं।

Answer 4

यदि std::string का उपयोग न करने के कोई विशेष कारण नहीं हैं, तो std::string का उपयोग करें।

लेकिन क्या तुम सच में उस चरित्र सरणी सदस्य प्रारंभ करने में है, तो जरूरत है:

#include <assert.h> 
#include <iostream> 
#include <string.h> 
using namespace std; 

class test 
{ 
    private: 
     char name[40]; 
     int x; 
    public: 
     test(); 
     void display() const 
     { 
      std::cout<<name<<std::endl; 
     } 
}; 

test::test() 
{ 
    static char const nameData[] = "Standard"; 

    assert(strlen(nameData) < sizeof(name)); 
    strcpy(name, nameData); 
} 

int main() 
{ 
    test().display(); 
} 

Answer 5

c++11 वास्तव में ऐसा करने के दो तरीके प्रदान करता है। आप सदस्य की घोषणा लाइन पर सदस्य को डिफ़ॉल्ट कर सकते हैं या आप कन्स्ट्रक्टर प्रारंभिक सूची का उपयोग कर सकते हैं। घोषणा लाइन प्रारंभ की

उदाहरण:

class test1 { 
    char name[40] = "Standard"; 
public: 
    void display() { cout << name << endl; } 
}; 

निर्माता आरंभीकरण का उदाहरण:

class test2 { 
    char name[40]; 
public: 
    test2() : name("Standard") {}; 
    void display() { cout << name << endl; } 
}; 

आप यहाँ इन दोनों का एक लाइव उदाहरण देख सकते हैं: http://ideone.com/zC8We9

मेरे निजी पसंद है घोषणा लाइन प्रारंभिकरण का उपयोग करने के लिए:

1. कहाँ कोई अन्य चर इस उत्पन्न डिफ़ॉल्ट निर्माता इस्तेमाल किया जा करने की अनुमति देता
2. कहाँ कई निर्माताओं के लिए आवश्यक हैं इस की अनुमति देता है चर केवल एक ही स्थान पर बजाय सभी निर्माता प्रारंभ सूचियों में प्रारंभ करने के लिए बनाया जाना चाहिए

---

यह सब कहा है, एक char[] उत्पन्न डिफ़ॉल्ट असाइनमेंट ऑपरेटर के रूप में हानिकारक माना जा सकता है का उपयोग कर, और कॉपी/कदम कंस्ट्रक्टर्स काम नहीं करेगा।

1. सदस्य const
2. बनाने का उपयोग करते हुए एक char* (यह तब सदस्य लेकिन एक शाब्दिक स्ट्रिंग कुछ भी आयोजन करेगा काम नहीं करेगा)
3. सामान्य स्थिति में std::string प्राथमिकता दी जानी चाहिए: यह द्वारा हल किया जा सकता