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
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
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