|
Identify and correct the error in the derived-class constructor syntax in this Java code.
class Employee { private String fName, 1Name; public Employee(String f, String 1) { fName = f; 1Name = 1; } } class Manager extends Employee { private short level; public Manager(String f, String 1, short 1v1) { Employee(f, 1); level = 1v1; } public Manager(String f, String 1) { this(f, 1, 10); } }
State what the data members of the following object will be set to after the following line is executed:
Employee e = new Manager ( "John", "Doe" );
Is the following C++ syntax legal? Note that the base classXand the derived classYuse the same identifiers m and foo for class members. Pay careful attention to the syntax used for the function calls in main. If the code is legal, what's its output?
class X { public: int m; X( int mm ) : m( mm ) {} void foo() { cout << "X's foo invoked" << endl; } }; class Y : public X { public: int m; Y( int a, int b ) : X(a), m( b ) {} void foo() { cout << "Y's foo invoked" << endl; } }; int main() { X xobj( 10 ); xobj.foo(); Y yobj( 10, 20 ); yobj.foo(); yobj.X::foo(); return 0; }
If the goal was to write correctly the copy constructor for a derived class in C++, is the following example correct? If not, how will you fix it?
class X { int m; public: X( int mm ) : m( mm ) {} X( const X& other ) : m( other.m ) {} }; class Y : public X { int n; public: Y( int mm, int nn ) : X( mm ), n( nn ) {} Y( const Y& other ) : n( other.n ) {} };
The following C++ program compiles without any problems. When run, it even prints out the "hello" called for in line (B) of main. But subsequently the program aborts with a memory segmentation fault. Why? (Hint: If you comment out the assignment statement in line (A), the program runs flawlessly.)
//MysteryBug.cc #include <iostream> using namespace std; class X { int* p; int size; public: X() { p = 0; size = 0; } X( int* ptr, int sz ) : size( sz ) { p = new int[ size ]; for ( int i=0; i<size; i++ ) p[i] = ptr[i]; } ~X() { delete[] p; } }; class Y : public X { int n; public: Y() {}; Y( int* ptr, int sz, int nn ) : X( ptr, sz ), n( nn ) {} Y( const Y& other ) : X( other ), n( other.n ) {} Y& operator=( const Y& other ) { if ( this == & other ) return *this; X: :operator=( other ); n = other.n; return *this; } }; int main() { int data[ 3 ] = {3, 2, 1}; Y y1( data, 3, 10 ); Y y2; y2 = y1; //(A) cout << "hello" << endl; //(B) return 0; }
While the following C++ program compiles fine
#include <iostream> using namespace std; class X { public: void foo(); X() { } }; class Y : public X { public: void foo() { cout << "Y's foo invoked" << endl; } Y() {} }; int main() {}
the following program does not compile and reports a problem from the linker. Why?
#include <iostream> #include <vector> using namespace std; class X { public: virtual void foo(); X() { } }; class Y : public X { public: void foo() { cout << "Y's foo invoked" << endl; } Y() {} }; int main() {}
Will the following C++ program compile?
class X { public: virtual void f(); }; class Y : public X { }; int main() { Y yobj; }
Will the following version of the previous program compile?
class X { public: virtual void f() = 0; }; class Y : public X { }; int main() { Y yobj; }
Will the following version of the previous program compile and run?
class X { public: virtual void f() = 0; }; class Y : public X { void f() {}; }; int main() { Y yobj; }
With regard to exception specifications for overriding functions in Java, is the following code legal?
class MyException extends Exception {} class X { public void foo() throws MyException { throw new MyException(); } } class Y extends X { public void foo() { System.out.printIn( "Y's foo invoked" ); } }
Do you see any problems with the following Java code? Note that both the interfaces X and Y possess a function of the same signature. Will this code fragment compile?
interface X { public int foo( int m ); } interface Y { public int foo( int n ); } class W implements X, Y { public int foo( int x ) { return x; } }
vis-à-vis the code in the previous problem, the Java code shown here shows two interfaces possessing function fooral> of the same name but different signatures. Do you see any problems with this code? Will it compile?
interface X { public int foo( int m ); } interface Y { public int foo( int n, int p ); } class W implements X, Y { public int foo( int x ) { return x; } }
Will the following Java program compile?
interface X { public int foo( int m ); } class X { public int foo( int q ) { return q; } } class W implements X { public int foo( int x ) { return x; } }
|