Interview questions

[cj]

Dear friends, I have one more questions for everyone in the newsgroup:

I am preparing for an interview on UNIX/C++. Could you please identify some
of the most important questions which might be asked, so that I could best
prepare for it?

Thank you,
C++J

[Risto Lankinen]

"JKop" <NU**@NULL.NULL > wrote in message
news:UE******** *********@news. indigo.ie...

JKop posted:

char jack reinterpret_cas t<char>(monkey s[5]);

TYPO

char jack = reinterpret_cas <char>(monkey s[5]);

'Tis not your day today... :-)

- Risto -

[Default User]

"E. Robert Tisdale" wrote:

Something that calls itself Default User wrote:

[nothing that has to do with C++.]
Unlike your post? Besides being a liar, you're a hypocrit.
Go away troll.

I'll make a deal with you. We'll have an on-line vote (not in the
group). Whoever gets the most votes as being a troll has to stop
posting.

You up for it, troll-boy?

Brian Rodenborn

[pembed2003]

Ioannis Vranos <iv*@guesswh.at .grad.com> wrote in message news:<cb******* ****@ulysses.no c.ntua.gr>...

Another interesting question that I would ask, in the advanced level
this one.


In a class hierarchy with virtual member functions, how much does the
time cost of calling a virtual function increases while the depth of
abstraction increases?
For example:
class base1
{
// ...
virtual void something();
};

class base2: public base1
{
// ...
void something();
};

//...

class base999999: public base999998
{
// ...
void something();
};
base1 *p1=new base78;

p1->something();
base1 *p2=new base999999;

p2->something();

How much more time it takes for the implementation to find and invoke
base999999::som ething() in comparison to base78::somethi ng()?

Hi,
As a new C++ programmer, I found your question very interesting. I
think it takes about the same time to find and invoke
base78::somethi ng() and base999999::som ething(), right? Because each
object carries a virtual table pointer (if the class has at least one
virtual function) with an bunch of virutal function pointers to the
possible function definition. The lookup (not sure how the actual
virtual table is implemented but if it's something like a binary tree
or hash table then...) thus takes appr. the same amount of time.

If I answered it incorrectly, can you provide the answer? I want to
learn.

Thanks!

[Ioannis Vranos]

pembed2003 wrote:

How much more time it takes for the implementation to find and invoke
base999999::s omething() in comparison to base78::somethi ng()?

Hi,
As a new C++ programmer, I found your question very interesting. I
think it takes about the same time to find and invoke
base78::somethi ng() and base999999::som ething(), right? Because each
object carries a virtual table pointer (if the class has at least one
virtual function) with an bunch of virutal function pointers to the
possible function definition. The lookup (not sure how the actual
virtual table is implemented but if it's something like a binary tree
or hash table then...) thus takes appr. the same amount of time.

If I answered it incorrectly, can you provide the answer? I want to
learn.

Yes the time cost is the *same* regardless the depth of the abstraction.

As it is written in TC++PL on page 324:
"Classical hierarchies do tend to couple implementation concerns rather
strongly with the interfaces provided to users. Abstract classes can
help here. Hierarchies of abstract classes provide a clean and powerful
way of expressing concepts without encumbering them with implementation
concerns or significant run-time overheads. After all, a virtual
function call is cheap and independent of the kind of abstraction
barrier it crosses. It costs no more to call a member of an abstract
class than to call any other virtual function."


Regards,

Ioannis Vranos

[E. Robert Tisdale]

pembed2003 wrote:

As a new C++ programmer, I found your question very interesting.
I think it takes about the same time to find and invoke
base78::somethi ng() and base999999::som ething(), right?
It depends upon the implementation.
But, yes, you are correct for typical implementations .
Because each object carries a virtual table pointer
(if the class has at least one virtual function)
with an bunch of virutal function pointers
to the possible function definition. The lookup
(not sure how the actual virtual table is implemented
but if it's something like a binary tree or hash table then...)
thus takes appr. the same amount of time.

If I answered it incorrectly, can you provide the answer?
I want to learn.

Actually, in Ioannis Vranos' example,
it appears that p1 and p2 are defined in the same scope
as the respective subsequent invocations of something(void) .
In this case, a good optimizing C++ compiler will emit code
to invoke the correct function directly
and will not even consult any virtual function table.

[pembed2003]

JKop <NU**@NULL.NULL > wrote in message news:<UE******* **********@news .indigo.ie>...

JKop posted:

Peter Koch Larsen posted:

I do believe that that question is a very bad one. The code above is
obviously portable, but these casts do confuse. What on earth are you
going to do with v? Any programmers instinct is that code must have "a
use", and it is quite difficult to see what you could portable do with
v.

What ever happened to just having fun?

int main(void)
{
int monkeys[7] = { 3, 4 ,3, 2 ,2 ,34, 23 ,3 };

char jack reinterpret_cas t<char>(monkey s[5]);

TYPO

char jack = reinterpret_cas <char>(monkey s[5]);

cout << jack;
}

Hi,
I am trying to compile your code using g++ in FreeBSD. g++ -v gives:

gcc version 2.95.3 20010125 (prerelease)

the whole program looks like:

#include<iostre am>
using namespace std;
void main(void){
int monkeys[8] = {3,4,3,2,2,34,2 3,3};
char jack = reinterpret_cas t<char>(monkey s[5]);
cout<<jack<<end l;
}

but it won't compile:

g++ tmp.cpp -o tmp
tmp.cpp: In function `int main(...)':
tmp.cpp:5: reinterpret_cas t from `int' to `char'

I am trying to understand your program but failed. Can you tell me
what you are trying to demonstrate and what the program is supposed to
do? I am trying to learn.

Thanks!

[Ioannis Vranos]

pembed2003 wrote:

Hi,
As a new C++ programmer, I found your question very interesting. I
think it takes about the same time to find and invoke
base78::somethi ng() and base999999::som ething(), right? Because each
object carries a virtual table pointer (if the class has at least one
virtual function) with an bunch of virutal function pointers to the
possible function definition. The lookup (not sure how the actual
virtual table is implemented but if it's something like a binary tree
or hash table then...) thus takes appr. the same amount of time.

If I answered it incorrectly, can you provide the answer? I want to
learn.

Thanks!

I had problems with my server today, so I repost:

Yes the time cost is the *same* regardless the depth of the abstraction.

As it is written in TC++PL on page 324:
"Classical hierarchies do tend to couple implementation concerns rather
strongly with the interfaces provided to users. Abstract classes can
help here. Hierarchies of abstract classes provide a clean and powerful
way of expressing concepts without encumbering them with implementation
concerns or significant run-time overheads. After all, a virtual
function call is cheap and independent of the kind of abstraction
barrier it crosses. It costs no more to call a member of an abstract
class than to call any other virtual function."


Regards,

Ioannis Vranos

[pembed2003]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote in message news:<cb******* **@nntp1.jpl.na sa.gov>...

pembed2003 wrote:

As a new C++ programmer, I found your question very interesting.
I think it takes about the same time to find and invoke
base78::somethi ng() and base999999::som ething(), right?

It depends upon the implementation.
But, yes, you are correct for typical implementations .

Because each object carries a virtual table pointer
(if the class has at least one virtual function)
with an bunch of virutal function pointers
to the possible function definition. The lookup
(not sure how the actual virtual table is implemented
but if it's something like a binary tree or hash table then...)
thus takes appr. the same amount of time.

If I answered it incorrectly, can you provide the answer?
I want to learn.

Actually, in Ioannis Vranos' example,
it appears that p1 and p2 are defined in the same scope
as the respective subsequent invocations of something(void) .
In this case, a good optimizing C++ compiler will emit code
to invoke the correct function directly
and will not even consult any virtual function table.

Hi Robert,
Is the "good optimizing C++ compiler will emit code to invoke the
correct function directly" feature a standard behavior? ie, is it
mentioned and allowed by the C++ standard?

Thanks!

[Rob Williscroft]

pembed2003 wrote in news:db******** *************** ***@posting.goo gle.com in
comp.lang.c++:

Actually, in Ioannis Vranos' example,
it appears that p1 and p2 are defined in the same scope
as the respective subsequent invocations of something(void) .
In this case, a good optimizing C++ compiler will emit code
to invoke the correct function directly
and will not even consult any virtual function table.

Hi Robert,
Is the "good optimizing C++ compiler will emit code to invoke the
correct function directly" feature a standard behavior? ie, is it
mentioned and allowed by the C++ standard?

The standard doesn't mention "virtual function table" so there
is no requirment that it be in the programme or that it be
consulted if it is.

The *only* requirment is that the correct function is called,
how that is achived doesn't matter.

Having said that, any programme can be optimised under the "as-if" rule.
i.e. as long as the programme behaves *as-if* the optimisation hadn't
been done then thats fine and dandy.

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Siemel Naran]

"Ioannis Vranos" <iv*@guesswh.at .grad.com> wrote in message news:cb7t18$1c1 9

E. Robert Tisdale wrote:

How much more time it takes for the implementation to find and invoke
base999999::som ething()
in comparison to base78::somethi ng()?

It depends upon the implementation (compiler).
In the typical implementation, it takes no more time.
The C++ computer programming language standard
does *not* specify implementations , performance or efficiency.

Wrong. Next please. :-)

What is wrong with Tisdale's answer (btw, is that the preferred short formal
name)?