Scribd
Upload
2 views

C++ vs Java

The document compares the behavior of C++ and Java regarding object slicing and polymorphism. In C++, object slicing occurs when a derived class object is assigned to a base class variable, leading to different results in method calls, while Java avoids this by using references. The document also provides solutions to mimic Java's behavior in C++ using pointers or references and emphasizes the importance of virtual functions for polymorphism.

Uploaded by

xvjtfy947p
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
2 views

C++ vs Java

The document compares the behavior of C++ and Java regarding object slicing and polymorphism. In C++, object slicing occurs when a derived class object is assigned to a base class variable, leading to different results in method calls, while Java avoids this by using references. The document also provides solutions to mimic Java's behavior in C++ using pointers or references and emphasizes the importance of virtual functions for polymorphism.

Uploaded by

xvjtfy947p
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/ 4

Student name: Nguyễn Phúc Điền

Student ID: 2352258


Group: CC01
C++ Java

#include <iostream> class A {


protected int a;
class A
public A() {
{
a = 10;
protected: }
int a;
public: public int f() {
A() {a = 10;} a++;
int f() {a++; return a;} return a;
int geta() {return a;} }
};
public int geta() {
return a;
}
}

class B: public A class B extends A {


{ @Override
public int f() {
public:
a--;
int f() {a--; return a;} return a;
}; }
}

int main() public class Main {


public static void
{
main(String[] args) {
int n; int n;
A a,a2; A a = new A();
B b; A a2 = new A();
B b = new B();
a.f();
b.f(); a.f();
b.f();
a2 = b;
a2 = b;
a2.f(); a2.f();

std::cout << a.geta() << " System.out.println(a.geta() + "


"<< b.geta() << " " " + b.geta() + " " +
<<a2.geta(); a2.geta());
}
}
return 0;
}

Result: 11 9 10 Result: 11 8 8

Question 1: Why do they give different results?


C++:
1. “a2 = b” performs object slicing (C++ special feature). This means that when the object b
of type B is assigned to a2 of type A, the part of b that is specific to B is sliced off, keeping
only the A portion

2. Even though b's value of a was decremented to 9 before the slicing, the sliced copy a2
has no knowledge of B's behavior, and fields inherited from B are copied by value

3. When calling “a2.f()”, it invokes A::f() (not B::f()), because a2 is now just of type A.
Therefore, the result is 10 (9 + 1 = 10)

→ RESULT: 11 9 10

Java:
In Java, there is no object slicing as in C++. Java uses references rather than direct value
assignment when working with objects, so “a2 = b” does not create a sliced copy; instead, a2
refers to the same B object

a.f(); → property a of object a is 11 = 10 + 1


b.f(); → property a of object b is 9 = 10 - 1
a2 = b; → makes a2 hold a reference to the same object as b, which means a2 and b refers
to the same object (same address in memory)
a2.f(); → calls f() on the same object referenced by a2 (which is really the B object). Since
a2 points to a B object and Java resolves methods based on the runtime type of the
object (polymorphism), B::f() is invoked. Property a of a2 (or b) is 8 = 9 - 1

→ RESULT: 11 8 8

Question 2: If we want C++ to act as Java, how can?

We can make C++ to act as Java by using pointers or references.


Below is the new code using pointers:
#include <iostream>

class A {
protected:
int a;
public:
A() { a = 10; }
virtual int f() { a++; return a; } // Use virtual for
polymorphism
int geta() { return a; }
};

class B : public A {
public:
int f() { a--; return a; }
};
int main() {
A a;
A* a2; // Pointer to base class A
B b;

a.f();
b.f();
a2 = &b; // Assign address of b to a2 (no slicing, a2 points
to b)
a2->f(); // Calls B::f() because a2 points to B, b.a becomes
8

std::cout << a.geta() << " " << b.geta() << " " << a2->geta()
<< std::endl;

return 0;
}

There are 2 different key changes in the new C++ code:


1.​ Declare a2 as a pointer of type A so that when assigning “a2 = &b;”, we make a2
point to b (no object slicing).
2.​ Make A::f() a virtual method for polymorphism. Without doing this, when we call
“a2→f();”, a2 will perform the A::f() method instead of performing polymorphism.

Another way is using reference:


#include <iostream>

class A {
protected:
int a;
public:
A() { a = 10; }
virtual int f() { a++; return a; } // Use virtual for
polymorphism
int geta() { return a; }
};

class B : public A {
public:
int f() override { a--; return a; } // Override for runtime
polymorphism
};

int main() {
A a;
B b;
A& a2 = b; // Use a reference to base class A, but point it to
b

a.f();
b.f(); // B::f(), b.a becomes 9
a2.f(); // Calls B::f() because a2 refers to B, b.a becomes
8

std::cout << a.geta() << " " << b.geta() << " " << a2.geta() <<
std::endl;

return 0;
}

There are 2 different key changes in the new C++ code:


1.​ Declare a reference to base class A, but point it to b. Therefore, when calling a2.f(),
actually it is B::f().
NOTE: references must be initialized immediately. We cannot declare it and assign
the value later.
2.​ Make A::f() a virtual method for polymorphism. Without doing this, when we call
“a2.f();”, a2 will perform the A::f() method instead of performing polymorphism.

You might also like