मैं C ++ का उपयोग करके एक पंक्ति में कई चर कैसे घोषित और परिभाषित कर सकता हूं?

Question

मैं हमेशा यद्यपि कि अगर मैं इन तीन चर की घोषणा करता हूं कि वे सभी मूल्य 0 होंगे

int column, row, index = 0;

लेकिन मुझे लगता है कि केवल इंडेक्स शून्य के बराबर है और अन्य जंक जैसे 844553 और 2423445 हैं।

नई चर रेखा पर प्रत्येक चर घोषित किए बिना मैं इन सभी चर को शून्य कैसे शुरू कर सकता हूं?

Comments

उन एक-लाइन बहु-चर घोषणाओं के साथ सावधान। यह आसान है कि आप नियमित पूर्णांक की सूची के बाद एक इंट्री पॉइंटर की घोषणा करना आसान समझते हैं ( int* a, b, c;जैसा दिखता है वैसा नहीं करता है)।

— क्रिस एबरले जूल

केवल तीन चर हैं, यार, =0अपनी परिभाषाओं में हर एक के लिए लिखें । और, यदि आप वास्तव में कई चर चाहते हैं, तो एक सरणी का प्रयास करें: आपके लिए int a[10]={0}प्रत्येक a[i]को 0 से प्रारंभ करेगा ।

— स्टेन

संकलक को उस निर्माण की अनुमति नहीं देनी चाहिए, अगर वह एक उचित प्रोग्रामर से अलग व्यवहार करने जा रहा है तो वह क्या करने की उम्मीद करेगा ... imho

— cph2117

@ cph2117 एक उचित प्रोग्रामर सोचता है कि 'हम्म, इस वाक्यविन्यास का मतलब अलग-अलग चीजों का एक जोड़ा हो सकता है जो इस बात पर निर्भर करता है कि व्याकरण चीजों को कैसे बांधता है' , मानक को देखें जो कि सत्य है, और इसके साथ मिलता है।

— अंडरस्कोर_ड

ऐसा करना बंद करो। यह सिर्फ पढ़ने के लिए कोड कठिन बनाता है। एक उच्च स्तरीय भाषा में कोड लिखने का उद्देश्य एक अनुचर को पढ़ने के लिए सरल बनाना है।

— मार्टिन यॉर्क

Answer 1

int column = 0, row = 0, index = 0;

Answer 2

जब आप घोषणा करते हैं:

int column, row, index = 0;

केवल सूचकांक शून्य पर सेट है।

हालाँकि आप निम्न कार्य कर सकते हैं:

int column, row, index;
column = index = row = 0;

लेकिन व्यक्तिगत रूप से मैं निम्नलिखित को पसंद करता हूं जिसे इंगित किया गया है।
यह मेरे विचार से अधिक पठनीय रूप है।

int column = 0, row = 0, index = 0;

या

int column = 0;
int row = 0;
int index = 0;

Comments

पिछले दो के बीच मैं यह तय करता हूं कि क्या दो मान वास्तव में एक ही प्रकार के होने चाहिए ( bool previousInputValue, presentInputValue;) या यदि वे अभी एक ही प्रकार के होते हैं, लेकिन वास्तव में होने की जरूरत नहीं है ( भविष्य में uint8_t height, width;बदल सकते uint8_t height; uint16_t width;हैं और होना चाहिए था uint8_t height; uint8_t width;शुरुआत के लिए)।

— अल्टेंस्की

क्योंकि लिखने के uint8_t height; uint16_t width;बजाय uint8_t height, width;भविष्य में 10 वर्ण बचाता है। :-) यदि आप चाहें, तो आप इसे बेशक कर सकते हैं। बस सुनिश्चित करें कि आप इसे आसानी से पढ़ सकते हैं। तो अंतिम रूप सबसे स्पष्ट है।

— मैट

अंतिम रूप निश्चित रूप से प्रत्येक चर के प्रकार को बताते हुए सबसे स्पष्ट है और यह स्पष्ट करता है कि प्रत्येक एक प्रारंभिक है। उस ने कहा, यह स्पष्ट नहीं है कि स्तंभ और पंक्ति एक ही प्रकार के होने की उम्मीद है या नहीं। शायद हम दोनों के साक्षी को पसंद करेंगे int presentValue = 0; typeof(presentValue) previousValue = presentValue;, लेकिन मेरा मानना ​​है कि typeof()यह एक गैर-मानक जीसीसी विस्तार है।

— ऑल्टेंडी

Answer 3

जैसा कि @ जोश ने कहा, सही उत्तर है:

int column = 0,
    row = 0,
    index = 0;

आपको पॉइंटर्स के साथ एक ही चीज़ देखने की आवश्यकता होगी। यह:

int* a, b, c;

के बराबर है:

int *a;
int b;
int c;

Comments

मुझे उस पॉइंटर चीज़ से नफरत है, इसका कोई मतलब नहीं है। तारांकन प्रकार का हिस्सा है, इसलिए यह उन सभी पर लागू होना चाहिए। कल्पना कीजिए कि क्या unsigned long x, y;घोषित किया xगया है, unsigned longलेकिन yसिर्फ unsignedउर्फ के रूप में unsigned int! बिलकुल वैसा ही! </ rant>

— कैम जैक्सन

यह समझ में आता है। "इंट * ए, बी, सी;"

— जीरो

@JeroenBollen खैर, यह समझ में आता है यदि आप अपने सूचक तारांकन प्रकार के बजाय चर नाम के आगे लिखते हैं, लेकिन यह अपने आप में कोई मतलब नहीं है। जैसा कि मैंने ऊपर कहा, तारांकन नाम का हिस्सा है, नाम का हिस्सा नहीं है, इसलिए इसे प्रकार के साथ समूहीकृत करना चाहिए!

— कैम जैक्सन

एक पक्ष के रूप में, वास्तव में यह समझ में नहीं आता है कि * आवश्यक रूप से प्रकार का हिस्सा नहीं है, जैसा int *aकि उस मूल्य का *aप्रतिनिधित्व करता है int।

— mdenton8

बिंदु पहले से ही बनाया गया है, लेकिन केवल इसे जोड़ने के लिए शून्य अनिवार्य रूप से एक प्रकार की कमी है, लेकिन आप अभी भी इसे इंगित कर सकते हैं। इस प्रकार क्यों void* aसंकलन और void *a, b, cनहीं होगा। यह युक्तिकरण मेरे लिए काम करता है।

— जोश सी

Answer 4

यदि आप प्रति लाइन एक चर / वस्तु की घोषणा करते हैं, तो यह न केवल इस समस्या को हल करता है, बल्कि यह कोड को स्पष्ट करता है और पॉइंटर्स की घोषणा करते समय मूर्खतापूर्ण गलतियों को रोकता है।

हालांकि अपने सवाल का सीधे जवाब देने के लिए, आपको प्रत्येक चर को स्पष्ट रूप से शुरू करना होगा। int a = 0, b = 0, c = 0;।

Answer 5

int column(0), row(0), index(0);

ध्यान दें कि यह फ़ॉर्म कस्टम प्रकारों के साथ भी काम करेगा, खासकर जब उनके निर्माता एक से अधिक तर्क लेते हैं।

Comments

और आजकल एक समान आरंभीकरण के साथ (लंबित C ++ 17 के लिए इसे ठीक कर रहा है auto...): int कॉलम { 0 } , पंक्ति { 0 } , सूचकांक { 0 } ;

— अंडरस्कोर_ड

Answer 6

2k18 तक, आप संरचित बाइंडिंग का उपयोग कर सकते हैं :

#include <iostream>
#include <tuple>

int main () 
{
    auto [hello, world] = std::make_tuple("Hello ", "world!");
    std::cout << hello << world << std::endl;
    return 0;
}

Demo

Answer 7

संभव दृष्टिकोण:

• शून्य के साथ सभी स्थानीय चर आरंभ करें।
• एक सरणी है, memsetया{0} सरणी है।
• इसे वैश्विक या स्थिर बनाएं।
• उन्हें अंदर रखें struct, memsetया उनके पास एक कंस्ट्रक्टर है जो उन्हें शून्य से आरंभ करेगा।

Comments

#define COLUMN 0 #define ROW 1 #define INDEX 2 #define AR_SIZE 3 int Data [ AR_SIZE ]; // एक विचार है।

— अजय

क्षमा करें, मेरा मतलब है, आपने अपने उत्तर में " क्या कोई सरणी, कोई मेमसेट या {0} एरे " पंक्ति शामिल की है ?

— मतीन उल्हाक

मेमसेट (डेटा, 0, साइज़ोफ़ (डेटा)); // अगर यह तार्किक रूप से पैक किया जा सकता है।

— अजय

Answer 8

मैं इसकी अनुशंसा नहीं करूंगा, लेकिन अगर आप वास्तव में एक पंक्ति में हैं और केवल एक बार 0 लिख रहे हैं, तो आप यह भी कर सकते हैं:

int row, column, index = row = column = 0;

Answer 9

जैसा कि दूसरों ने उल्लेख किया है, सी ++ 17 के बाद से आप कई चर असाइनमेंट के लिए संरचित बाइंडिंग का उपयोग कर सकते हैं ।

इसे std::arrayऔर टेम्पलेट तर्क कटौती के साथ जोड़कर हम एक फ़ंक्शन लिख सकते हैं जो कि प्रकार या मूल्य को दोहराए बिना एक मनमाने ढंग से चर की संख्या प्रदान करता है ।

#include <iostream>
#include <array>

template <int N, typename T> auto assign(T value)
{
    std::array<T, N> out;
    out.fill(value);
    return out;
}

int main()
{
    auto [a, b, c] = assign<3>(1);

    for (const auto& v : {a, b, c})
    {
        std::cout << v << std::endl;
    }

    return 0;
}

Demo

Answer 10

जब आप किसी वेरिएबल को बिना इनिशियलाइज़ किए घोषित करते हैं, तो मेमोरी से एक रैंडम नंबर सिलेक्ट किया जाता है और वैरिएबल को उस वैल्यू के लिए इनिशियलाइज़ किया जाता है।

Comments

ज़रुरी नहीं। संकलक 'इस चर का पता xxx पर होगा' तय करता है, जो कुछ भी पता xxx पर हुआ है वह प्रारंभिक मूल्य होगा जब तक कि इसका सेट स्पष्ट रूप से (आरंभ या असाइनमेंट द्वारा)

— pm100

@ pm100 हालांकि बेहतर है , और किसी भी तुच्छ कार्यान्वयन के लिए सही है, जो उपयोगकर्ताओं को परेशान करने के लिए अपने रास्ते से बाहर नहीं जाता है ... जो कि अभी भी असंगत है ;-) जैसा कि एक असंवैधानिक चर का उपयोग करना यूबी है, इसलिए सिद्धांत रूप में कुछ भी हो सकता है, किसी भी कोड सहित उस वैरिएबल का उपयोग करके प्रोग्राम से बाहर निकाला जा रहा है - जो कि विशेष रूप से तब संभव है जब ऑप्टिमाइज़ेशन प्ले में हो।

— अंडरस्कोर_ड

उस वैरिएबल का मान जो कुछ भी था, वह उस पते पर होगा, जो रद्दी है।

— पेड्रो वर्नेटी

@PedroVernetti यह बात मायने नहीं रखती कि नए चर घोषित होने से पहले क्या कहा गया था और उसी पते पर हुआ था। यदि उपयोगकर्ता एक मान के साथ इसे शुरू किए बिना नए चर की घोषणा करता है, और फिर इसे एक मान निर्दिष्ट करने से पहले चर को पढ़ता है, तो कार्यक्रम में अपरिभाषित व्यवहार होता है। यह "यादृच्छिक" और "जंक" की तुलना में असीम रूप से खराब है और इससे बचने की आवश्यकता है।

— अंडरस्कोर_ड