Strooustrup - Hello World exercise
arnuld
main() ). Given this program:
#include <iostream>
int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}
modify it to produce the output:
Initialize
Hello World!
Clean up
Do not change main() in anyway.
I really don't understand how to go about it.
--
www.lispmachine.wordpress.com
my email is @ the above blog.
Google Groups a.k.a "Spammer's Paradise" is Blocked.
Juan Antonio Zaratiegui Vallecillo
> Section 10.6, Exercise 15 ( I only added "return 0" to the original
> main() ). Given this program:
>
>
> #include <iostream>
>
> int main()
> {
> std::cout << "Hello World!" << std::endl;
>
> return 0;
> }
>
>
>
> modify it to produce the output:
>
> Initialize
> Hello World!
> Clean up
>
>
> Do not change main() in anyway.
>
>
> I really don't understand how to go about it.
>
* What does std::cout mean or represent?
* What does << mean or represent?
* Whta does std::endl mean or represent?
Once you have answered those questions, you will know the answer to your
problem.
Best regards,
Zara
Eberhard Schefold
> * What does std::cout mean or represent?
> * What does << mean or represent?
> * Whta does std::endl mean or represent?
>
> Once you have answered those questions, you will know the answer to your
> problem.
I'm not sure whether you've really noticed the "Do not change main() in
any way" part.
Eberhard Schefold
> Section 10.6, Exercise 15 ( I only added "return 0" to the original
> main() ).
... which is not necessary, actually (main() is treated specially in
this regard).
> #include <iostream>
>
> int main()
> {
> std::cout << "Hello World!" << std::endl;
>
> return 0;
> }
>
> modify it to produce the output:
>
> Initialize
> Hello World!
> Clean up
>
>
> Do not change main() in anyway.
You know that the normal flow of the program goes through main(), so any
change should be forbidden. There is another mechanism in C++, though;
Objects can reside in a "space" somewhat outside the "normal flow". If
you remember what that space is, you should be able to fulfill the
requirement.
arnuld
> You know that the normal flow of the program goes through main(), so any
> change should be forbidden. There is another mechanism in C++, though;
> Objects can reside in a "space" somewhat outside the "normal flow". If
> you remember what that space is, you should be able to fulfill the
> requirement.
You are talking about the "classes", which I don't know yet how to write.
However here is my half-knowledged and uncompilable attempt:
#include <iostream>
class Pre_sentence
{
public:
void print_initialize();
};
class Post_sentence
{
public:
void print_cleanup();
};
Pre_sentence print_begin;
Post_sentence print_end;
print_begin::print_initialize;
int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}
void Pre_sentence::print_initialize()
{
std::cout << "Initialize" << std::endl;
}
void Post_sentence::print_cleanup()
{
std::cout << "Clean up" << std::endl;
DJ Dharme
You are so close to the answer, there are two special methods in a
class. If you find them you will know the answer.
olekk
arnuld wrote:
> Section 10.6, Exercise 15 ( I only added "return 0" to the original
> main() ). Given this program:
>
>
> #include <iostream>
>
> int main()
> {
> std::cout << "Hello World!" << std::endl;
>
> return 0;
> }
>
>
>
> modify it to produce the output:
>
> Initialize
> Hello World!
> Clean up
>
>
> Do not change main() in anyway.
>
>
> I really don't understand how to go about it.
>
#include <iostream>
struct Initializer
{
Initializer() { std::cout<<"Initialize"<<std::endl;}
~Initializer(){ std::cout<<"Cleen up"<<std::endl;}
};
Initializer myInit;
int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}
Global object will be created before main executed and destroyed after
sean_in...@yahoo.com
> Section 10.6, Exercise 15 ( I only added "return 0" to the original
> main() ).
Note that unlike C, C++ has an implicit "return 0;" at the end.
A. Bolmarcich
>> On Thu, 30 Oct 2008 11:31:39 +0100, Eberhard Schefold wrote:
>
>> You know that the normal flow of the program goes through main(), so any
>> change should be forbidden. There is another mechanism in C++, though;
>> Objects can reside in a "space" somewhat outside the "normal flow". If
>> you remember what that space is, you should be able to fulfill the
>> requirement.
>
>
> You are talking about the "classes", which I don't know yet how to write.
> However here is my half-knowledged and uncompilable attempt:
In your opening post to this thread you mentioned "Section 10.6,
Exercise 15". Because chapter 10 is about Classes you need to know
how to write classes to be able to do the exercises for that chapter.
Informataion needed to do the exercise is in the subsection on
Construction and Destruction.
Juha Nieminen
> Initializer myInit;
As a matter of principle, I would have written that as:
namespace { Initializer myInit; }
Or at the very least as:
static Initializer myInit;
You should abhor global variables, even if it doesn't matter. Just a
question of principles.
Default User
Juan Antonio Zaratiegui Vallecillo
Oh sorry, you are right. I thought I had seen the usual homework question
arnuld
> Oh sorry, you are right. I thought I had seen the usual homework question
I don't get homework . I am no longer a kid ;)
arnuld
> In your opening post to this thread you mentioned "Section 10.6,
> Exercise 15". Because chapter 10 is about Classes you need to know
> how to write classes to be able to do the exercises for that chapter.
Actually, I wanted to start my abandoned learning of C++ and my
friend's Stroustrup was lying in front of me on my office desk. My
experience has taught me I can not learn programming my following a book
from cover to cover. So I opened the book at some random place and tried
to solve the exercise that came in front of me.
> Informataion needed to do the exercise is in the subsection on
> Construction and Destruction.
How about this:
#include <iostream>
class Useless
{
public:
Useless() { std::cout << "Initialize" << std::endl; }
~Useless() { std::cout << "Clean up" << std::endl; }
};
Useless obj_of_useless;
int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}
=========================== OUTPUT ====================================
[arnuld@dune cpp]$ g++ -ansi -pedantic -Wall -Wextra 10-6_15.cpp
[arnuld@dune cpp]$ ./a.out
Initialize
Hello World!
Clean up
[arnuld@dune cpp]$
Juan Antonio Zaratiegui Vallecillo
>> On Fri, 31 Oct 2008 09:52:36 +0100, Juan Antonio Zaratiegui Vallecillo
>
>> Oh sorry, you are right. I thought I had seen the usual homework question
>
>
> I don't get homework . I am no longer a kid ;)
>
>
gw7...@aol.com
> How about this:
>
> #include <iostream>
>
> class Useless
> {
> public:
> Useless() { std::cout << "Initialize" << std::endl; }
> ~Useless() { std::cout << "Clean up" << std::endl; }
>
> };
>
> Useless obj_of_useless;
>
> int main()
> {
> std::cout << "Hello World!" << std::endl;
>
> return 0;
>
> }
Yes, that looks just the sort of thing they were after.
Paul.
blargg
<491f5749-f52b-4614...@k36g2000pri.googlegroups.com>,
gw7...@aol.com wrote:
> On 30 Oct, 20:41, arnuld <sunr...@invalid.address> wrote:
> > How about this:
> >
> > #include <iostream>
> >
> > class Useless
> > {
> > public:
> > =A0 Useless() =A0{ std::cout << "Initialize" << std::endl; }
> > =A0 ~Useless() { std::cout << "Clean up" =A0 << std::endl; }
> >
> > };
> >
> > Useless obj_of_useless;
> >
> > int main()
> > {
> > =A0 std::cout << "Hello World!" << std::endl;
> >
> > =A0 return 0;
> >
> > }
>
> Yes, that looks just the sort of thing they were after.
Unlike this questionable solution that defines no new classes:
#include <iostream>
#include <cstdlib>
namespace
{
void cleanup() { std::cout << "Clean up\n"; }
int init = (std::cout << "Initialize\n", std::atexit( cleanup ));
}
int main() { }
Stuart Golodetz
> Section 10.6, Exercise 15 ( I only added "return 0" to the original
> main() ). Given this program:
>
>
> #include <iostream>
>
> int main()
> {
> std::cout << "Hello World!" << std::endl;
>
> return 0;
> }
>
>
>
> modify it to produce the output:
>
> Initialize
> Hello World!
> Clean up
>
>
> Do not change main() in anyway.
>
>
> I really don't understand how to go about it.
Clearly the constructor/destructor way (see other posts) is the intended
way to go about it, but just for fun:
(a)
#include <iostream>
#define main f
int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}
#undef main
#define f main
int f()
{
std::cout << "Initialize" << std::endl;
std::cout << "Hello World!" << std::endl;
std::cout << "Clean up" << std::endl;
return 0;
}
(b)
#include <stdio.h>
namespace N { namespace std {
struct X {} cout;
struct Y {} endl;
X& operator<<(X& x, const char *p)
{
printf("Initialize\n%s\nClean up", p);
return x;
}
X& operator<<(X& x, const Y&)
{
printf("\n");
return x;
}
}}
using namespace N;
int main()
{
std::cout << "Hello World!" << std::endl;
return 0;
}
***
I'm not 100% sure whether the second one's legal or not (anyone?). I
know it's illegal to randomly add stuff to the std namespace
(specializations of operators etc. aside), but is my attempt to get
around that restriction (above) valid? I'm curious...
Cheers,
Stu
Juha Nieminen
> arnuld wrote:
>> Do not change main() in anyway.
>>
>
> way to go about it, but just for fun:
>
> (a)
>
> #include <iostream>
>
> #define main f
>
> int main()
The original problem says "do not change main() *in any way*". I
understand that to include using the preprocessor to change it.
arnuld
I don't understand one thing here, constructor is called as soon as the
object is created but when does destructor is called:
1) when main() goes out of scope in the program. Its is not feasible
because in main() the "return 0" exits the program.
2) The destructor is called just before "return 0" ?
--
www.lispmachine.wordpress.com
my email is @ the above blog.
Google Groups is UnBlocked now :)
MPNIKHIL
Cant one use operator overloading for accomplishing this?
Pete Becker
>
> I don't understand one thing here, constructor is called as soon as the
> object is created but when does destructor is called:
>
>
> 1) when main() goes out of scope in the program. Its is not feasible
> because in main() the "return 0" exits the program.
>
> 2) The destructor is called just before "return 0" ?
Standard-conforming code can't tell the difference, so from one
perspective, that distinction doesn't matter.
On a practical note, though, the destructor is called after the return
from main. In C, running a program effectively executes
exit(main(...)), and the exit function, in theory, deals with any
cleanup that's needed. In fact, there's usually quite a bit of code
that gets executed before entry into main and quite a bit that gets
executed after the return from main, and most of it isn't contained in
the exit function. Your compiler supplies whatever code is needed to
set up and tear down the program's environment, and that includes
running constructors and destructors.
--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)
Juha Nieminen
> 1) when main() goes out of scope in the program. Its is not feasible
> because in main() the "return 0" exits the program.
No, the "return 0" exits main(). There's a difference. Nothing stops
the compiler from executing code after main() has ended.
Stuart Golodetz
I was working on the assumption that it meant "don't change the *text*
of main in any way". But you're right, it's open to a number of
different interpretations. If one wanted to be particularly annoying,
for instance, one could specify that that included not changing the
position of main within the file. I guess it's still possible in that
case: you just include a different header instead of iostream which has
a name with exactly the same length as iostream and includes it, e.g.
// wibble.h
#include <iostream>
// The extra code you actually wanted to put in the main file goes here
...
// main.cpp
#include "wibble.h"
int main()
{
...
}
But at that point it's starting to get a little silly! :-)
Stu