Scribd
Upload
18 views5 pages

Scope Resolution in C++

The document explains the scope resolution operator (`::`) in C++, which is used to access members from specific scopes, resolve ambiguities, and improve code organization. It also discusses the differences between shallow copy and deep copy in C++, highlighting their definitions, memory allocation, impact on original objects, performance, use cases, and associated risks. Examples are provided for both concepts to illustrate their functionality and implications.

Uploaded by

Ajay Choudhary
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
18 views5 pages

Scope Resolution in C++

The document explains the scope resolution operator (`::`) in C++, which is used to access members from specific scopes, resolve ambiguities, and improve code organization. It also discusses the differences between shallow copy and deep copy in C++, highlighting their definitions, memory allocation, impact on original objects, performance, use cases, and associated risks. Examples are provided for both concepts to illustrate their functionality and implications.

Uploaded by

Ajay Choudhary
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Scope Resolution in C++

what is use of scope resolution in oops in c++

The scope resolution operator (`::`) in C++ is used to access members (variables, functions, or classes)
that belong to a specific scope. It helps resolve ambiguity when multiple scopes have elements with the
same name.

Uses of Scope Resolution Operator (`::`) in OOPs (C++)

1. Access Global Variables When Shadowed

cpp

#include <iostream>
using namespace std;
int x = 10; // Global variable

class Test {
public:
int x = 20; // Member variable
void show() {
cout << "Local x: " << x << endl;
cout << "Global x: " << ::x << endl; // Accessing global x
}
};

int main() {
Test obj;
obj.show();
return 0;
}

Output:

sql

Local x: 20
Global x: 10

2. Define Class Member Functions Outside the Class

cpp

class Demo {
public:
void show(); // Function prototype
};

void Demo::show() { // Function definition outside class


cout << "Scope Resolution Operator Example" << endl;
}

int main() {
Demo obj;
obj.show();

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 1/5
return 0;
}

3. Access Static Class Members

cpp

class Sample {
public:
static int count;
};

int Sample::count = 100; // Initialize static variable outside the class

int main() {
cout << "Static count: " << Sample::count << endl;
return 0;
}

Output:

scss

Static count: 100

4. Access Base Class Members in Multiple Inheritance

cpp

class A {
public:
void show() { cout << "Class A" << endl; }
};

class B {
public:
void show() { cout << "Class B" << endl; }
};

class C : public A, public B {


public:
void display() {
A::show(); // Resolving ambiguity
B::show();
}
};

int main() {
C obj;
obj.display();
return 0;
}

Output:

css

Class A
Class B

5. Access Namespace Members

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 2/5
cpp

#include <iostream>
namespace ns {
int x = 50;
}

int main() {
cout << "Namespace x: " << ns::x << endl;
return 0;
}

Output:

vbnet

Namespace x: 50

Thus, the scope resolution operator (`::`) helps access specific elements across different scopes,
prevents ambiguity, and ensures better code organization.

difference between shallow copy and deep copy in c++

Difference Between Shallow Copy and Deep Copy in C++

Feature Shallow Copy Deep Copy


Copies object members as they are, Creates a new copy of dynamically allocated
Definition including pointers (only the memory memory (allocates new memory and copies
address is copied). actual values).
Memory The new object shares the same memory The new object gets separate memory for
Allocation for dynamically allocated members. dynamically allocated members.
Changes in copied object do not affect the
Impact on Changes in copied object affect the
original object (since a new copy of data is
Original Object original object (due to shared memory).
created).

Slower, as it allocates new memory and copies


Performance Faster, as only pointers are copied.
the data.
Used when an object does not contain Used when an object has dynamically allocated
Use Case
dynamically allocated memory. memory to avoid accidental modifications.
Causes issues like dangling pointers and
Avoids such issues by maintaining
Risk double deletion during object
independent copies.
destruction.

Example of Shallow Copy

cpp

#include <iostream>
using namespace std;

class Shallow {
public:

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 3/5
int* ptr;

// Constructor
Shallow(int val) {
ptr = new int(val);
}

// Default Copy Constructor (Shallow Copy)


Shallow(const Shallow& obj) {
ptr = obj.ptr; // Only copies the pointer address, not the actual value.
}

// Destructor
~Shallow() {
delete ptr; // May cause issues when multiple objects share the same pointer.
}
};

int main() {
Shallow obj1(10);
Shallow obj2 = obj1; // Shallow Copy

cout << "obj1: " << *obj1.ptr << endl;


cout << "obj2: " << *obj2.ptr << endl;

*obj2.ptr = 20; // Modifies obj1.ptr as well


cout << "After modification:" << endl;
cout << "obj1: " << *obj1.ptr << endl;
cout << "obj2: " << *obj2.ptr << endl;

return 0;
}

Output:

yaml

obj1: 10
obj2: 10
After modification:
obj1: 20
obj2: 20

🔴 Problem: Both `obj1` and `obj2` share the same memory. When one is modified, the other also gets
affected.

Example of Deep Copy

cpp

#include <iostream>
using namespace std;

class Deep {
public:
int* ptr;

// Constructor
Deep(int val) {
ptr = new int(val);
}

// Deep Copy Constructor


Deep(const Deep& obj) {
ptr = new int(*obj.ptr); // Creates a new copy of the data.
}

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 4/5
// Destructor
~Deep() {
delete ptr;
}
};

int main() {
Deep obj1(10);
Deep obj2 = obj1; // Deep Copy

cout << "obj1: " << *obj1.ptr << endl;


cout << "obj2: " << *obj2.ptr << endl;

*obj2.ptr = 20; // Changes only obj2


cout << "After modification:" << endl;
cout << "obj1: " << *obj1.ptr << endl;
cout << "obj2: " << *obj2.ptr << endl;

return 0;
}

Output:

yaml

obj1: 10
obj2: 10
After modification:
obj1: 10
obj2: 20

✅ Solution: Each object gets its own memory, preventing unintended modifications.
Conclusion

Use shallow copy when objects do not contain dynamically allocated memory.
Use deep copy when objects contain dynamically allocated memory to ensure each object has its
own copy.

For dynamically allocated objects, always implement deep copy to avoid dangling pointers and
memory leaks.

Printed using ChatGPT to PDF, powered by PDFCrowd HTML to PDF API. 5/5

You might also like