Jag sitter här o proggar C++ och har nu stött på lite problem. Jag har ju ingen aning om hur man använder try och catch i C++! Vad är det man ska fånga? Är det Exception som i Java, eller?
<font size="1" face="Verdana, Arial, Helvetica, sans-serif">Kod:<font size="1" face="Verdana, Arial, Helvetica, sans-serif" color="#666600">
try {
iInteger = atoi(cInteger);
} catch(***VAD SKA VARA HÄR?***) {
cout << "Nejdu, bara siffror ska det vara...";
}
Osså en liten undran om rekursiva funktioner. Om jag anropar funktionen innefrån ett catch-block, kommer den första funktionen köras färdigt när programmet "hoppar" hoppar tillbaka till den, eller är det bara den rekursiverade funktionen som körs?
Alltså:
<font size="1" face="Verdana, Arial, Helvetica, sans-serif">Kod:<font size="1" face="Verdana, Arial, Helvetica, sans-serif" color="#666600">
void minFunk() {
// Gör lite grejs
try {
iInteger = atoi(cInteger);
} catch(???) {
cout << "Nejdu...";
minFunk();
}
// Gör inte det här om catch-blocket kördes vid första anropet av funktionen!
}
Hoppas ni förstår vad jag menar, och att ni har någon lösning på det :)
------------------
---
/* LilleSkutt */
Ok, nu har jag lyckats klura ut vad man fångar ivf :)
En const char* str.
Däremot kvarstår den andra frågan, plus denna:
Varför kan man inte göra så här? Jag vill lägga in hela filen i en char-vector, men så här gick det ju inte...
<font size="1" face="Verdana, Arial, Helvetica, sans-serif">Kod:<font size="1" face="Verdana, Arial, Helvetica, sans-serif" color="#666600">
const char* minFunk() {
const char *result;
result = " ";
try {
ifstream f;
f.open("minFil.txt");
result = f.rdbuf();
f.close();
return result;
}
catch(const char\* exception) {
return result;
}
}
------------------
---
/* LilleSkutt */
Du kan kasta vad som helst. Det bästa är att subklassa std::exception i någon form. Titta på filen <stdexcept>, där finns några tips. Se även mitt exempel nedan.
Använder du catch (...) fångas allt. Det är inte speciellt smart - fånga sånt du kan hantera och försök inte gömma programmeringsfel är en bra strategi.
#include <stdexcept>
#include <exception>
#include <string>
#include <iostream>
#include <new.h>
static int OnException(size_t)
{
throw std::bad_alloc();
return 0;
}
class MyException : public std::exception
{
public:
enum ErrorType
{
MissingFile,
RainyDay,
};
private:
ErrorType m_ErrorType;
public:
MyException(ErrorType et, const char *message) : exception(message), m_ErrorType(et)
{
}
};
void Kasta(int i)
{
switch (i)
{
case 0:
throw 3;
case 1:
new byte[1*1024*1024*1024]; // kommmer ge bad_alloc
case 2:
throw MyException(MyException::MissingFile, "Hittade inte c:\\fil.txt");
case 3:
throw std::invalid_argument("Must be a valid name"); // fångas av logic_error nedan
case 4:
throw std::runtime_error("Out of disk space");
case 5:
throw 'a'; // fångas av catch (...)
default:
throw "default";
}
}
void main()
{
using std::string;
using std::cout;
using std::endl;
\_set_new_handler(OnException);
for (int i=0; i\<6; ++i)
{
try
{
cout \<\< i \<\< ": ";
Kasta(i);
}
catch (std::runtime_error e)
{
cout \<\< "runtime_error: " \<\< e.what() \<\< endl ;
}
catch (std::logic_error e)
{
cout \<\< "logic_error: " \<\< e.what() \<\< endl ;
}
catch (std::bad_alloc e)
{
cout \<\< "slut på minne: " \<\< e.what() \<\< endl ;
}
catch (std::exception e)
{
cout \<\< "exception: " \<\< e.what() \<\< endl ;
}
catch (const char \*str)
{
cout \<\< "string:" \<\< str \<\< endl;
}
catch (int i)
{
cout \<\< "tal:" \<\< i \<\< endl;
}
catch (...)
{
cout \<\< "annat exception" \<\< endl;
}
}
}
Ok, tack för den bamsebra koden :)
Lite svårt att hänga med på en del grejjer, men det ska nog gå att smälta. Är det ok om jag använder en del av koden du bifogade i programmet?
Hur för man över en hel fils innehåll till en variabel i programmet? :q
------------------
---
/* LilleSkutt */
"bamse-bra"... hahaha! :)
Visst får du använda exemplet.
Rent allmänt är det inte alltid så snyggt att läsa in en hel fil i en sträng. Använd isåfall en buffer och läs in ett antal tecken i taget. Det beror på tillämpningen. Jobbar du med stora datamängder är kanske 64 kB en bra buffertstorlek. I andra fall kanske 64 Bytes är bra. Det är svårt att ge tips utan att veta vad du gör.
STL har ganska mycket filhantering, vill du gå in på det finns det bra böcker (finns säkert tutorials på nätet, men jag rekommenderar ändå en bra bok).
<font size="1" face="Verdana, Arial, Helvetica, sans-serif">Kod:<font size="1" face="Verdana, Arial, Helvetica, sans-serif" color="#666600"> // --------------------------------------------------
// Exempel 1
// Använd iteratorer för att gå igenom tecken för tecken
// --------------------------------------------------
std::ifstream InFile("c:\\\\fil.txt"); // textfil som måste finnas
istreambuf_iterator\<char\> InFileIter(InFile);
istreambuf_iterator\<char\> EofIter; // pekar på end-of-file
while (InFileIter != EofIter)
{
cout \<\< \*InFileIter++;
}
// --------------------------------------------------
// Exempel 2
// Läs in i en buffer
// --------------------------------------------------
// Gå till början av filen
InFile.seekg(0);
char buf\[32\];
while (!InFile.eof())
{
InFile.read(buf, sizeof(buf)-sizeof(char));
cout \<\< buf;
}
