c++ * और** और सी++ में मतलब




सी++ प्रोग्राम (5)

मैंने इन प्रतीकों को एक समारोह घोषणा में कई बार पाया, लेकिन मुझे नहीं पता कि उनका क्या मतलब है।

उदाहरण:

void raccogli_dati(double **& V, double **p, int N) { 
  int ultimo = 3; 
  V = new double * [N/2]; 
  for(int i=0; i < N/2; i++) { 
    V[i] = new double[N/2], std :: clog << "digita " << N/2 - i
                 << " valori per la parte superiore della matrice V: "; 
    for(int j=i; j < N/2; j++) 
      std :: cin >> V[i][j], p[ultimo++][0] = (V[i][j] /= sqrt(p[i][0]*p[j][0]));
  } 
  for(int i=1; i < N/2; i++) 
    for(int j=0; j < i; j++) 
       V[i][j] = V[j][i];
}

उन वाक्यांशों को समझने के लिए चलो कुछ चीजों को देखें:

typedef double Foo;
void fooFunc(Foo &_bar){ ... }

तो यह संदर्भ द्वारा एक डबल गुजर रहा है।

typedef double* Foo;
void fooFunc(Foo &_bar){ ... }

अब यह संदर्भ के आधार पर एक सूचक को गुजर रहा है।

typedef double** Foo;
void fooFunc(Foo &_bar){ ... }

आखिरकार, यह संदर्भ के आधार पर एक पॉइंटर को पॉइंटर पास कर रहा है। यदि आप इस तरह के टाइपपीफ के मामले में सोचते हैं तो आप और * प्लस के उचित क्रम को समझेंगे।


सबसे पहले एक पॉइंटर का संदर्भ है, दूसरा पॉइंटर के लिए पॉइंटर का संदर्भ है। पॉइंटर्स और संदर्भ कैसे भिन्न होते हैं, इस पर भी अक्सर पूछे जाने वाले प्रश्न देखें।

void foo(int*& x, int**& y) {
    // modifying x or y here will modify a or b in main
}

int main() {
    int val = 42;
    int *a  = &val;
    int **b = &a;

    foo(a, b);
    return 0;
}

वह संदर्भ द्वारा पैरामीटर ले रहा है। तो पहले मामले में आप संदर्भ द्वारा एक पॉइंटर पैरामीटर ले रहे हैं, इसलिए जो भी पॉइंटर के मान पर आप संशोधन करते हैं वह फ़ंक्शन के बाहर दिखाई देता है। दूसरा एकमात्र अंतर है जिसमें केवल एक ही अंतर है कि यह एक डबल सूचक है। यह उदाहरण देखें:

void pass_by_value(int* p)
{
    //Allocate memory for int and store the address in p
    p = new int;
}

void pass_by_reference(int*& p)
{
    p = new int;
}

int main()
{
    int* p1 = NULL;
    int* p2 = NULL;

    pass_by_value(p1); //p1 will still be NULL after this call
    pass_by_reference(p2); //p2 's value is changed to point to the newly allocate memory

    return 0;
}

वह मूल्य के बजाय संदर्भ द्वारा एक सूचक को गुजर रहा है। उदाहरण के लिए यह फ़ंक्शन में सूचक (पॉइंट-ऑब्जेक्ट नहीं) को बदलने की अनुमति देता है, इस तरह कॉलिंग कोड परिवर्तन को देखता है।

की तुलना करें:

void nochange( int* pointer ) //passed by value
{
   pointer++; // change will be discarded once function returns
}

void change( int*& pointer ) //passed by reference
{
   pointer++; // change will persist when function returns
}

*& संदर्भ द्वारा सूचक प्राप्त करने का संकेत देता है। इसका मतलब है कि यह गुजरने वाले पैरामीटर के लिए उपनाम है। तो, यह गुजरने वाले पैरामीटर को प्रभावित करता है।

#include <iostream>
using namespace std;

void foo(int *ptr)
{
    ptr = new int(50);    // Modifying the pointer to point to a different location
    cout << "In foo:\t" << *ptr << "\n"; 
    delete ptr ;
}

void bar(int *& ptr)
{
    ptr = new int(80);    // Modifying the pointer to point to a different location
    cout << "In bar:\t" << *ptr << "\n"; 
    // Deleting the pointer will result the actual passed parameter dangling
}
int main()
{
    int temp = 100 ;
    int *p = &temp ;

    cout << "Before foo:\t" << *p << "\n";
    foo(p) ;
    cout << "After foo:\t" << *p << "\n";

    cout << "Before bar:\t" << *p << "\n";
    bar(p) ;
    cout << "After bar:\t" << *p << "\n";

    delete p;

    return 0;
}

आउटपुट:

Before foo: 100
In foo: 50
After foo:  100
Before bar: 100
In bar: 80
After bar:  80




symbols