Eine Deklaration verschattet einen Parameterfehler in C++

1. Zugriffsbezeichner in C++
2. Declaration Shadows a Parameter-Fehler in C++

Es gibt immer einige Grenzen, Bereiche oder Geltungsbereiche jedes Objekts oder jeder Variablen, um auf andere Klassenmitglieder wie Datenmitglieder oder Mitgliedsfunktionen zuzugreifen, die durch Zugriffsspezifizierer in C++ als öffentlich, privat oder geschützt definiert sind.

Wenn wir eine Variable mehr als einmal mit demselben Namen in einem bestimmten Bereich oder Block des Programms definieren, verwirrt der Compiler und gibt einen Fehler aus, der besagt, dass eine Deklaration einen Parameter überschattet.

Zugriffsbezeichner in C++

Bevor Sie auf die Details des Shadow-Parameters eingehen, ist es wichtig, die Zugriffsspezifizierer zu verstehen. Im Allgemeinen sind drei Zugriffsspezifizierer öffentlich, privat und geschützt.

Spezifizierer für öffentlichen Zugriff in C++

Ein Public-Spezifizierer macht alle Member (Daten-Member oder Member-Funktionen) einer Klasse öffentlich, auf die im gesamten Programm von anderen Klassen aus zugegriffen werden kann; Mit dem Punkt . können Sie direkt auf diese Mitgliederfunktionen zugreifen. Operator mit dem Objekt derselben Klasse.

#include <iostream>
using namespace std;
// class definition
class Cal_Circle {
 public:  // Public access specifier
  double radius;
  double compute_area() { return 3.14 * radius * radius; }
};

// main function
int main() {
  Cal_Circle obj;
  // accessing public datamember outside class
  obj.radius = 3.4;
  cout << "Radius of the circle is: " << obj.radius << "\n";
  cout << "Area of the circle is: " << obj.compute_area();
  return 0;
}

Ausgang:

Radius of the circle is: 3.4
Area of the circle is: 36.2984

Privater Zugriffsspezifizierer in C++

Der ‘Private’-Zugriffsspezifizierer hält jedes Mitglied, entweder Datenmitglied oder Mitgliedsfunktion, innerhalb der Grenzen einer Klasse privat. Auf sie kann außerhalb der Klasse nicht direkt durch das Objekt dieser Klasse zugegriffen werden.

Sie sind vor dem Zugriff außerhalb der Klasse verborgen, um die Sicherheit des Programms zu gewährleisten.

#include <iostream>
using namespace std;
// class definition
class Cal_Circle {
 private:  // private access specifier
  double radius;
  double compute_area() { return 3.14 * radius * radius; }
};

// main function
int main() {
  Cal_Circle obj;
  // accessing public datamember outside class
  obj.radius = 3.4;
  cout << "Radius of the circle is: " << obj.radius << "\n";
  cout << "Area of the circle is: " << obj.compute_area();
  return 0;
}

Ausgang:

error: 'double Cal_Circle::radius' is private within this context
   obj.radius = 3.4;
note: declared private here
     double radius;
note: declared private here
     double compute_area(){

In diesem Beispiel haben wir den Zugriffsspezifizierer als privat verwendet und über das Objekt der Klasse aus der Hauptfunktion darauf zugegriffen. Und es wirft einen Fehler für jedes Klassenmitglied, das hier als geschützt deklariert wird.

Geschützter Zugriffsspezifizierer in C++

In ähnlicher Weise kann auf den Zugriffsspezifizierer Protected außerhalb seiner Klasse nicht direkt über das Objekt dieser Klasse zugegriffen werden, aber der Unterschied besteht darin, dass auf die Klasse Protected oder Mitglieder über die Ableitungsklasse zugegriffen werden kann.

Über das Objekt der abgeleiteten Klasse kann auf die geschützten Member einer Klasse zugegriffen werden.

#include <iostream>
using namespace std;

class Radius {  // Base class
 protected:     // protected access specifier
  double radius;
};

class Cal_Circle : public Radius {  // Derive class
 public:                            // private access specifier
  double compute_area(int a) {
    radius = a;
    return 3.14 * radius * radius;
  }
};

// main function
int main() {
  Cal_Circle obj;
  // accessing public datamember outside class
  cout << "Area of the circle is: " << obj.compute_area(3);
  return 0;
}

Ausgang:

Area of the circle is: 28.26

Unsere Basisklasse ist geschützt und hat einen Datenmember radius. Wir haben diese Basisklasse an Cal_Circle geerbt und greifen mit dem Objekt der abgeleiteten Klasse auf das geschützte Datenelement radius zu.

Wir greifen indirekt auf die geschützten Mitglieder einer geschützten Klasse zu.

Declaration Shadows a Parameter-Fehler in C++

Bei der Computerprogrammierung gibt es bestimmte Grenzen, die als Umfang bekannt sind. Dies kann ein if-else-Block, eine Funktion oder eine Klasse sein.

Eine innerhalb eines if-else-Blocks, einer Funktion oder einer Klasse definierte Variable kann nicht verwendet werden, bis Sie sie als öffentlich definiert haben. Und auf eine öffentliche Variable, Funktion oder Klasse kann im gesamten Programm zugegriffen werden.

Außerdem ist es in C++ verboten, eine Variable innerhalb eines bestimmten Gültigkeitsbereichs zweimal oder öfter zu definieren. Und wenn Sie dies tun, wird ein Fehler ausgegeben, da eine Deklaration einen Parameter überschattet.

Lassen Sie es uns anhand eines Beispiels verstehen.

#include <iostream>

int doublenumber();
using namespace std;

int doublenumber(int x) {
  int x;  // We are redefining the same variable as the parameter of the
          // function
  return 2 * x;
  cout << endl;
}

int main() {  // Main function
  int a;
  cout << "Enter the number that you want to double it : " << endl;
  cin >> a;
  int d = doublenumber(a);
  cout << "Double : " << d << endl;
  return 0;
}

Ausgang:

Test.cpp: In function 'int doublenumber(int)':
Test.cpp:6:9: error: declaration of 'int x' shadows a parameter
   int x;

Wie wir gesehen haben, können wir eine Variable nicht mehr als einmal in einem bestimmten Codeblock wie Funktion, Klasse und einem if-else-Block definieren.

In der Funktion doublenumber() haben wir einen Parameter int x, und im Rahmen dieser Funktion definieren wir auch ein weiteres lokales int x, das den Parameter überschattet und einen Fehler auslöst.