[C++/linux] Hello World problemen*

[Verwijderd]

Beste programmeurs,

Eergisteren heb ik mij het boek "C++ zonder stress" van Oliver Bohm (Easy Computing) aangeschaft. Het leek mij een erg duidelijk boek en er stond achterop dat je het ook met de GCC compiler kon gebruiken. Ik dus vandaag met frisse moed aan de slag gegaan op mijn Suse Linux 9.3 bak.

Als ik ecter de code geef:

code:

#include <iostream.h>

main() 
{
    cout << "Hello world\n";
}

dan krijg ik een bak aan foutmeldingen terug:

code:

In file included from /usr/include/c++/3.3.5/backward/iostream.h:31,
                 from helloworld.cpp:1:
/usr/include/c++/3.3.5/backward/backward_warning.h:32:2: warning: #warning This file includes at least one deprecated or antiquated header. Please consider using one of the 32 headers found in section 17.4.1.2 of the C++ standard. Examples include substituting the <X> header for the <X.h> header for C++ includes, or <sstream> instead of the deprecated header <strstream.h>. To disable this warning use -Wno-deprecated.
/tmp/ccXQM0wC.o(.text+0xa): In function `main':
helloworld.cpp: undefined reference to `std::cout'
/tmp/ccXQM0wC.o(.text+0xf):helloworld.cpp: undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
/tmp/ccXQM0wC.o(.text+0x3d): In function `__static_initialization_and_destruction_0(int, int)':
helloworld.cpp: undefined reference to `std::ios_base::Init::Init[in-charge]()'
/tmp/ccXQM0wC.o(.text+0x6a): In function `__tcf_0':
helloworld.cpp: undefined reference to `std::ios_base::Init::~Init [in-charge]()'
/tmp/ccXQM0wC.o(.eh_frame+0x11): undefined reference to `__gxx_personality_v0'
collect2: ld returned 1 exit status

Help! In het boek wordt uitgegaan van GCC compiler v. 2.9, ik gebruik v. 3.3.5. Is het boek misschien gewoon te veel verouderd? Kunnen jullie mijn code verbeteren zodat ik straks lkkr kan devven op mijn Linux bak?

[Verwijderd]

Probeer eens zonder .h

[ Voor 12% gewijzigd door Verwijderd op 18-06-2005 12:15 ]

[knopper]

C++:

#include <iostream>

using namespace std;

int main () {

    cout << "Hello world!\n";
}

zou moeten werken, suc6!

[raoulduke]

Verwijderd schreef op zaterdag 18 juni 2005 @ 12:12:
Beste programmeurs,

Eergisteren heb ik mij het boek "C++ zonder stress" van Oliver Bohm (Easy Computing) aangeschaft. Het leek mij een erg duidelijk boek en er stond achterop dat je het ook met de GCC compiler kon gebruiken. Ik dus vandaag met frisse moed aan de slag gegaan op mijn Suse Linux 9.3 bak.

Als ik ecter de code geef:

code:

...

Help! In het boek wordt uitgegaan van GCC compiler v. 2.9, ik gebruik v. 3.3.5. Is het boek misschien gewoon te veel verouderd? Kunnen jullie mijn code verbeteren zodat ik straks lkkr kan devven op mijn Linux bak?

Euh, iets als

code:

#include <stdio.h>

int main(int argc, char* argv[]) {
 printf("Hello World!\n");
 return;
}

Ik ben niet zo'n C guru, maar dat zou moeten werken.

[ Voor 48% gewijzigd door raoulduke op 18-06-2005 12:15 ]

[Verwijderd]

Willen de posters misschien aangeven waarom men deze code moet gebruiken i.p.v wat er in het boek staat? Onder Mac OS X met Xcode Tools 2.1 moet ik ook perse deze code gebruiken anders wil het niet werken.

code:

#include <iostream>

int main (int argc, char * const argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    return 0;
}

[dingstje]

raoulduke schreef op zaterdag 18 juni 2005 @ 12:15:
[...]

Ik ben niet zo'n C guru, maar dat zou moeten werken.

Daar zeg je het al, C. De mens vraagt C++, het zal wel lukken om te compilen als C++, maar waarschijnlijk klopt de uitleg in het boek dan niet meer.

Edit: je moet std::cout gebruiken omdat je dit lijntje niet vooraan gezet hebt:

code:

using namespace std;

Door deze lijn bovenaan te zetten kan je alle functies uit de std namespace gebruiken zonder er std:: te moeten voorzetten.

[ Voor 28% gewijzigd door dingstje op 18-06-2005 12:22 ]

[Verwijderd]

knopper schreef op zaterdag 18 juni 2005 @ 12:14:

C++:

#include <iostream>

using namespace std;

int main () {

    cout << "Hello world!\n";
}

zou moeten werken, suc6!

Thnx, dit werkte wel! Wat een snelle reacties hier op GOT zeg.

[knopper]

Ok, even wat uitleg:

je moet "#include <iostream>" gebruiken omdat "iostream.h" deprecated is. Dit zie je ook terug in de berichten v.d. compiler als je het compiled.

Een gevolg hiervan is dat je "using namespace std" moet toevoegen omdat je anders het volgende zou moeten schrijven: std::cout << "Hello World!\n";

Door die regel toe te voegen kun je het weer gewoon op de gebruikelijke manier doen zoals in het voorbeeld.

[Zoijar]

Wat is er mis met "using std::cout;" ? Dit is al zooooo vaak gezegd...inject nou niet een complete namespace, inject wat je nodig hebt...bovendien is er niets mis met gewoon "std::cout << "Foo!" << std::endl;" te schrijven. Die "\n" is ook not-done, gebruik std::endl.

(oh en voor de TS, ik denk dat je een oud boek hebt. C++ is redelijk veranderd sindsdien, het is misschien een idee om een iets nieuwer boek te kopen, het lieftst van na 1996.)

[ Voor 34% gewijzigd door Zoijar op 18-06-2005 12:57 ]

[Vinnienerd]

Wat is precies het nadeel van een hele namespace injecten? Trage code? Een grotere binary?

[Zoijar]

Vinnienerd schreef op zaterdag 18 juni 2005 @ 13:44:
Wat is precies het nadeel van een hele namespace injecten? Trage code? Een grotere binary?

Vnl. ambiguity. Nee, je code wordt er niet trager of groter van. Maar je weet niet wat je inject, als je de hele namespace pakt. Er kan prima een declaratie bijzitten die je zelf ook al gebruikt. En wat als je twee namespaces inject, die een aantal dezelfde declaraties bevatten? Dan moet je alsnog aangeven welke je wilt. Jouw code breekt dus door toevoegingen aan een library van 3e; niet echt netjes. Stel dit:

C++:

namespace Library {
    int Foo(int x) {return x;}
    //int Bar(int y) {return y;}
}

using namespace Library;

int Bar(int y) {return y+1;}

int main(int argc, char* argv[]) {
    Foo(1);
    Bar(2);

    return 0;
}

Dit compiled prima, iedereen blij. Een jaar later beslist je library vendor toch om ar op te nemen in de lib (die misschien heel iets anders doet dan jouw bar). Hier is dat hetzelfde als die ene regel uncommenten. Jouw code wordt opnieuw gecompileerd door een inmiddels ander persoon...d:\programming\testprog\main.cpp(12): error C2668: 'Bar' : ambiguous call to overloaded function. Leuk. Not.

Er zijn nog andere soort gelijke situaties te bedenken. Maar de bottomline is: het is bad practice om een hele namespace te injecten.

[MSalters]

Concreter: je wilt std::swap en "gewoon" swap gescheiden houden. Je eigen classes zouden namelijk ook een swap moeten hebben. Die kan vaak wel in std:: (als specialisatie!) maar soms niet (als het zelf een template is). De std:: algortimes nemen dan ook aan dat ze een willekeurig type T met swap(T&,T&) kunnen swappen - dus niet std:: !

[.oisyn]

En nog erger wordt het als de ::Bar een char verwacht, dan krijg je dus geen ambiguity foutmelding. En waar de Bar(1) regel voorheen nog je ::Bar(char) aanroepte, roept hij nu ineens Library::Bar(int) aan. En je hebt daar totaal geen idee van, er zijn immers geen foutmeldingen, de verkeerde functie wordt gewoon aangeroepen

[Verwijderd]

Oke, zal ik nu maar aan het begin van de code using namespace std; gebruiken, of toch steeds werken met std:: Ik heb de tegenargumenten voor het gebruik van namespace std gelezen, alleen daar snap ik niet zoveel van. Welke van de twee is "beter"?

[Soultaker]

Voor testcode of snel geschreven programma's is "using namespace std;" wel ok; in grotere bestanden wil je dat waarschijnlijk liever niet doen. Ik zou sowieso NOOIT using...-declaraties in header files zetten; dat is vragen om problemen.

Verder kun je trouwens ook specifieke declaraties importeren. Als je alleen vector en string wilt gebruiken, bijvoorbeeld:

C++:

#include <vector>
#include <string>
using std::string;
using std::vector;

int main()
{
    vector<string> foo;
    ...
}

[farlane]

Zoijar schreef op zaterdag 18 juni 2005 @ 12:55:
Die "\n" is ook not-done, gebruik std::endl.

Volgens mij is dat toch echt wel anders. std::endl flushed ook de output terwijl '\n' dat niet doet.

[Zoijar]

farlane schreef op maandag 20 juni 2005 @ 13:06:
Volgens mij is dat toch echt wel anders. std::endl flushed ook de output terwijl '\n' dat niet doet.

Ja, ok, daar heb je gelijk in. Vanwege het feit dat in- en output stream tied zijn, is er geen rede tot een flush. En alles dat std::endl doet is het aanroepen van o.put(o.widen('\n')); o.flush(); Maar het is vaak wel wat je bedoelt; ik put nu een regel, en ik wil hem nu op het scherm heben. Met alleen de \n is het mogelijk dat je bv output "Please wait for 5 minutes...calculating", en dat dat na die 5 minuten pas op het scherm komt.

[farlane]

Zoijar schreef op maandag 20 juni 2005 @ 15:06:
Met alleen de \n is het mogelijk dat je bv output "Please wait for 5 minutes...calculating", en dat dat na die 5 minuten pas op het scherm komt.

Die kans zit er wel in. Feit is wel dat de '\n' een portable manier is om een newline te printen zonder dat de output geflushed wordt dus het is zeker geen 'not done' iets.

[dingstje]

Je zou net denken dat het omgekeerd is: een compiler kan voor een bepaald platform namelijk de bedoeling van std::endl implementeren. Niet elk OS gebruikt dezelfde manier van newlines.

[farlane]

dingstje schreef op maandag 20 juni 2005 @ 15:31:
Je zou net denken dat het omgekeerd is: een compiler kan voor een bepaald platform namelijk de bedoeling van std::endl implementeren. Niet elk OS gebruikt dezelfde manier van newlines.

Jawel want je compileert voor een bepaald platform. Je vergist je met het feit dat de C++ standaard dat niet kan.

[_JGC_]

farlane schreef op maandag 20 juni 2005 @ 16:28:
[...]


Jawel want je compileert voor een bepaald platform. Je vergist je met het feit dat de C++ standaard dat niet kan.

Je compileert voor een bepaald platform idd, maar je compiler zal nooit jouw statische strings met \n erin kunnen converteren naar \r\n, dat doet geen enkele compiler.

[farlane]

_JGC_ schreef op maandag 20 juni 2005 @ 16:37:
Je compileert voor een bepaald platform idd, maar je compiler zal nooit jouw statische strings met \n erin kunnen converteren naar \r\n, dat doet geen enkele compiler.

Dat hoeft de compiler ook niet te doen want dat wordt door de systeem lib afgehandeld. Die ziet een '\n' en vertaalt dat naar de goede escape sequence.

Het is op zich niet anders dan de std::endl die volgens mij alleen maar iets doet als

C++:

stream.write( '\n' ); 
stream.flush();

[TheBlasphemer]

Erm, ik kon zo snel niet zien of iemand hier al een oplossing voor heeft gevonden,
maar ikzelf heb ook wel eens wat ruzie gehad met Linux en C++.

Niks wou compilen met gcc, altijd linker warnings,
tot ik eens g++ heb gebruikt, is gewoon zelfde syntax als gcc, maar deze werkt WEL met C++ bestanden

Probeer eens g++ te gebruiken ipv gcc, en vertel me of het is gelukt

Groeten,
TB