c++ - पॉइंट को चार बनाम पॉइन्टर को एरेज़ में




pointers char (3)

मैं h क्यों मुद्रित कर सकता हूँ और उत्पादन के रूप में अच्छा है और मैं p साथ ऐसा नहीं कर सकता? यह भी दिखता है कि जब मैं वृद्धि h++ हूं और इसे फिर से प्रिंट करता हूं, मैं फिर से मिलती onjour कैसे char साथ संकेत संकेतक होते हैं?

मानक पुस्तकालय operator<< दो अधिभार प्रदान करता है operator<< पॉइंटर्स से निपटने के लिए फ़ंक्शन

एक सदस्य फ़ंक्शन अधिभार:

basic_ostream& operator<<( const void* value );

और एक गैर सदस्य समारोह अधिभार:

template< class Traits >
basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os,  
                                        const char* s );

पहली बार जब cout << ptr का उपयोग सभी संकेतों के लिए किया जाता है जो कि प्रकार के char* या char const* के नहीं होते हैं दूसरे का उपयोग उन सभी पॉइंटरों के लिए किया जाता है जो कि टेप char* या char const* । दूसरा एक सबकुछ को समाप्त करने वाले रिक्त वर्णों तक पहुंचाता है, जबकि पहले एक को केवल सूचक मूल्य दिखाता है।

यह उत्पादन बताते हैं

यह समझने के लिए शिक्षाप्रद है कि मानक पुस्तकालय उन्हें अलग-अलग तरीके से क्यों व्यवहार करता है

भाषा और मानक पुस्तकालय रिक्त समाप्त स्ट्रिंग्स को अपवाद बनाते हैं जो कि char* और char const* द्वारा दर्शाए गए हैं। स्ट्रिंग के साथ काम करते समय, शून्य वर्ण ( '\0' ) एक संवेदी मान के रूप में कार्य करता है जो स्ट्रिंग के अंत के निशान करता है। अन्य प्रकारों के लिए ऐसा कोई मूल्य नहीं है। इसलिए, एक int* इलाज नहीं किया जा सकता था एक char* था

मैंने सोचा कि जब तक मैंने कुछ तथाकथित तुच्छ उदाहरणों की समीक्षा करने का निर्णय नहीं लिया, तब तक मुझे पॉइंटर्स का सभ्य ज्ञान मिला।

एक बात मुझे पता है कि जब एक सरणी घोषित करते हैं तो कहें:

int arr[2] {3, 5};

arr सरणी में पहला तत्व का मान रखेगा ताकि प्रिंट करने का प्रयास किया जा सके ( cout << arr ) जाहिर है arr[0] का पता यहां तक ​​कि सोचा कि मेरा प्रोग्राम पॉइंटर्स का उपयोग करता है, यह अभी भी समान है।

मेरा प्रश्न यह है कि मैं h क्यों मुद्रित कर सकता हूं और उत्पादन के रूप में अच्छा कर सकता हूं, लेकिन मैं p साथ ऐसा नहीं कर सकता?

यह भी लगता है कि जब मैं h++ बढ़ाता हूं और इसे फिर से मुद्रित कर लेता हूं तो मुझे onjour । पॉइंटर्स char साथ कैसे अलग होते हैं?

#include <iostream>
#include <string>

int main()
{
    char* h = "bonjour";
    int k[4]{3, 4, 5, 6};
    int * p = k;

    std::cout << "Hello, "<< h << "!\n";
}

जब आप h स्ट्रीम करते हैं, तो आप इस अधिभार का उपयोग कर रहे हैं:

template< class Traits >
basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os,  
                                        const char* s );

लेकिन जब आप स्ट्रीम करते हैं, तो आप इसका उपयोग कर रहे हैं:

basic_ostream& operator<<( const void* value );

पूर्व प्रत्येक बाइट को तब तक मुद्रित करेगा जब तक कि वह एक \0 तक न हो जाए, बाद वाले पते को प्रिंट कर देगा। यही है - बस const char* लिए एक विशेष मामला है कि आप इसका लाभ उठा रहे हैं


char* कुछ परिस्थितियों में विशेष हो सकते हैं, क्योंकि सी ने तार का प्रतिनिधित्व करने के लिए इसका उपयोग करने का निर्णय लिया। उस स्थिति में एक char* वर्णों की एक निरर्थक समाहित सरणी को संदर्भित करता है, उर्फ ​​सी-स्ट्रिंग कारण है कि आप h मुद्रित कर सकते हैं लेकिन p नहीं है क्योंकि एक समारोह मौजूद है जो कि char* लिए विशेष हैंडलिंग करता है:

 std::ostream::operator<<(std::ostream& os, const char*);

आप नल टर्मिनिज्ड पूर्णांक एरेज़ को प्रिंट करने के लिए अपनी खुद की अधिभार प्रदान कर सकते हैं:

std::ostream& operator<<(std::ostream& os, const int* arr) {
   while (int i = *arr++) {
      os << i;
      if (*arr) os << ", ";
   }
   return os;
}

int main()
{
  const int arr[] = {1, 2 ,3, 4, 0};
  std::cout << arr << "\n";
}

हालांकि, यह बेहद खतरनाक है क्योंकि अधिकांश पूर्णांक सरणियों को शून्य से समाप्त नहीं किया जाता है और पूर्णांक में सभी सूचक नहीं सरणी हैं।







char