Una declaración sombrea un error de parámetro en C++

1. Especificadores de acceso en C++
2. Error Declaration Shadows a Parameter en C++

Siempre hay algunos límites, rangos o alcance de cada objeto o variable para acceder a otros miembros de la clase, como miembros de datos o funciones miembro definidas por especificadores de acceso en C++ como público, privado o protegido.

Cuando definimos una variable más de una vez con los mismos nombres en el ámbito o bloque específico del programa, los compiladores se confunden y arrojan un error que dice una declaración sombrea un parámetro.

Especificadores de acceso en C++

Antes de entrar en los detalles del parámetro shadow, es importante comprender los especificadores de acceso. Generalmente, tres especificadores de acceso son público, privado y protegido.

Especificador de acceso público en C++

Un especificador Público hace que todos los miembros (miembros de datos o funciones de miembro) de una clase sean públicos, a los que se puede acceder a través del programa desde otras clases; puede acceder directamente a esas funciones miembro usando el punto . operador con el objeto de esa misma clase.

#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;
}

Producción :

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

Especificador de acceso privado en C++

El especificador de acceso Private mantiene cada miembro, ya sea miembro de datos o función de miembro, privado dentro de los límites de una clase. No se puede acceder a ellos fuera de la clase directamente por el objeto de esa clase.

Están ocultos del acceso fuera de la clase para garantizar la seguridad del programa.

#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;
}

Producción :

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(){

En este ejemplo, hemos utilizado el especificador accedido como privado y accedido a él a través del objeto de la clase desde la función principal. Y arroja un error para cada miembro de la clase que se declara protegido aquí.

Especificador de acceso protegido en C++

De manera similar, no se puede acceder al especificador de acceso Protegido fuera de su clase directamente a través del objeto de esa clase, pero la diferencia es que se puede acceder a la clase o miembros Protegidos a través de la clase derivada.

Utilizando el objeto de la clase derivada, puede acceder a los miembros protegidos de una clase.

#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;
}

Producción :

Area of the circle is: 28.26

Nuestra clase base está protegida y tiene un miembro de datos radius. Hemos heredado esa clase base a Cal_Circle, y con el objeto de la clase derivada, estamos accediendo al miembro de datos protegidos radius.

Estamos accediendo indirectamente a los miembros protegidos de una clase protegida.

Error Declaration Shadows a Parameter en C++

En la programación de computadoras, existen ciertos límites conocidos como alcance. Esto podría ser un bloque if-else, una función o una clase.

Una variable definida dentro de un bloque, función o clase if-else no se puede usar a menos y hasta que la haya definido como pública. Y se puede acceder a una variable, función o clase pública a través del programa.

Además, está prohibido en C++ definir una variable dos veces o más dentro de un ámbito específico. Y cuando lo haces, se arroja un error como una declaración ensombrece un parámetro.

Entendámoslo a través de un ejemplo.

#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;
}

Producción :

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

Como hemos visto, no podemos definir una variable más de una vez en un bloque específico de código como función, clase y un bloque if-else.

En la función doublenumber(), tenemos un parámetro int x, y en el ámbito de esta función, también estamos definiendo otro int x local, que sombrea el parámetro y arroja un error.