---
title: "operatorn new - undantag (xalloc) fråga"
type: "forum-thread"
url: "https://www.webforum.nu/amne/c-cpp/73279-operatorn-new-undantag-xalloc-fråga"
topic: "C/C++"
topic_url: "https://www.webforum.nu/amne/c-cpp"
author: "forum"
published: "2003-04-06T06:13:23.000Z"
updated: "2003-04-06T16:05:15.000Z"
replies: 9
views: 250
page: 1
pages: 1
language: "sv-SE"
site: "webForum — webforum.nu"
rights: "Upphovsrätten till varje inlägg tillhör dess författare."
attribution: "Citera som: webForum, https://www.webforum.nu/amne/c-cpp/73279-operatorn-new-undantag-xalloc-fråga"
---

# operatorn new - undantag (xalloc) fråga

## #1 — forum, 2003-04-06T06:13Z

Hej!

Hur ska jag bära mig åt för att fånga upp att det inte finns tillräckligt med minne vid en allokering, om så är fallet.

Så här ser min kod ut:

\#include \<iostream.h\>
\#include \<stdio.h\>
\#include \<except.h\>

class OutOfMemory {};

void main(void)
{
int\* myInt;

	try
   {
      myInt = new int(30);
   }
   catch(xalloc)
   {
   	cout \<\< "Kunde inte reservera minne";
   }
   getchar();
   delete myInt;
}

,,,Men det verkar inte funka. Jag kan, till synes iallafall, allokera minne för hur många intar som helst.

Vad gör jag för fel?

Tacksam för svar.

Permalänk: https://www.webforum.nu/p/73279

## #2 — Beatbox, 2003-04-06T09:56Z

Som jag ser det så gör new en "throw()" enbart och du försöker fånga nått annat. Prova catch(...) istället.

Permalänk: https://www.webforum.nu/p/1001591

## #3 — Sang-drax, 2003-04-06T10:25Z

Nej, new gör inte en throw;

Det du ska fånga är std::bad_alloc&

```
#include <new>
int* p;
try
{
  p = new int[1000000000];
}
catch (std::bad_alloc& e)
{
  std:cout << "Allokering misslyckades";
}
```

Permalänk: https://www.webforum.nu/p/1001619

## #4 — Sang-drax, 2003-04-06T10:26Z

En sak till:

myInt = new int(30); 

reserverar \*inte\* 30 stycken ints, utan en enda som får värdet 30.

Permalänk: https://www.webforum.nu/p/1001623

## #5 — aasah, 2003-04-06T10:35Z

Jag är ingen stjärna på det här, och har aldrig använt det själv, så ta det med en nypa salt. Men det jag har fått lära mig är följande:

När new misslyckas kastas - enligt default - ett bad_alloc som är subklass till exception. För att kunna fånga det i en catch sats \*måste\* man ha med 
\#include \<new\> //bland det man inkluderar
annars kastas det, men du kan inte fånga det med
catch(bad_alloc &e) {} 
Jag \*tror\* att man måste använda referenser, vet dock inte varför.

(((Sedan: det är väl inte förvånande att du kan skapa godtyckligt många intar? Hur lite minne har du egentligen?!? Idag är det ju oftast svårt att slå i minnestaket och att göra det med små intar borde vara ännu svårare?)))  OBS! Föreg. är feltänkt från början till slut!

Permalänk: https://www.webforum.nu/p/1001630

## #6 — Sang-drax, 2003-04-06T12:54Z

> **aasah skrev:**
>
> När new misslyckas kastas - enligt default - ett bad_alloc som är subklass till exception.

Rätt.

> **aasah skrev:**
>
> För att kunna fånga det i en catch sats \*måste\* man ha med 
> \#include \<new\> //bland det man inkluderar
> annars kastas det, men du kan inte fånga det med
> catch(bad_alloc &e) {}

Du kan antingen fånga det som exception eller bad_alloc

> **aasah skrev:**
>
> Jag \*tror\* att man måste använda referenser, vet dock inte varför.

Man *måste* inte använda referenser, men det är absolut bäst att göra det, eftersom exception& fångar även underklasser till exception. Då missar man inga fel i onödan.

> **aasah skrev:**
>
> Sedan: det är väl inte förvånande att du kan skapa godtyckligt många intar? Hur lite minne har du egentligen?!? Idag är det ju oftast svårt att slå i minnestaket och att göra det med små intar borde vara ännu svårare?

Det är väl inte svårt? Denna allokering kommer inte att fungera på någon Windows-dator.
int\* p = new int\[1000000000\];

Permalänk: https://www.webforum.nu/p/1001762

## #7 — aasah, 2003-04-06T13:09Z

> **Sang-drax skrev:**
>
> > **aasah skrev:**
> >
> > För att kunna fånga det i en catch sats \*måste\* man ha med 
> > \#include \<new\> //bland det man inkluderar
> > annars kastas det, men du kan inte fånga det med
> > catch(bad_alloc &e) {}
>
> 
> Du kan antingen fånga det som exception eller bad_alloc

Visst, men inte utan \#include \<new\>, väl?

> **Sang-drax skrev:**
>
> > **aasah skrev:**
> >
> > Jag \*tror\* att man måste använda referenser, vet dock inte varför.
>
> 
> Man *måste* inte använda referenser, men det är absolut bäst att göra det, eftersom exception& fångar även underklasser till exception. Då missar man inga fel i onödan.

??? Hittar vi fler exceptions med exception& än med exception\* ? Skulle vi missa subklasserna om vi fångade in pekare till undantagen i stället? Varför?

> **Sang-drax skrev:**
>
> > **aasah skrev:**
> >
> > Sedan: det är väl inte förvånande att du kan skapa godtyckligt många intar? Hur lite minne har du egentligen?!? Idag är det ju oftast svårt att slå i minnestaket och att göra det med små intar borde vara ännu svårare?
>
> 
> Det är väl inte svårt? Denna allokering kommer inte att fungera på någon Windows-dator.
> int\* p = new int\[1000000000\];

Nej, det är riktigt. Jag tänkte inte längre än min korta näsa när jag skrev det... Sorry!

Permalänk: https://www.webforum.nu/p/1001770

## #8 — Sang-drax, 2003-04-06T14:43Z

> **aasah skrev:**
>
> Visst, men inte utan \#include \<new\>, väl?

Jo då.

```
#include <iostream>
#include <exception>
int main()
{
    using namespace std;

    try
    {
        int* p = new int[1000000000];
    }
    catch (exception& e)
    {
        cout << "misslyckat: " << e.what() ;
    }
}
```

Skriver ut
"misslyckat: bad_alloc"

Det är det som är det braiga med OOP och arv.

> **aasah skrev:**
>
> ??? Hittar vi fler exceptions med exception& än med exception\* ? Skulle vi missa subklasserna om vi fångade in pekare till undantagen i stället? Varför?

Du kan inte fånga pekare till exceptions, endast objektsvis och med referenser.

Permalänk: https://www.webforum.nu/p/1001849

## #9 — Sang-drax, 2003-04-06T14:50Z

Förtydligande:

Man **missar** ingenting med att fånga som objekt, men jämför dessa två kodsnuttar så förstår du skillnaden:

```
#include <iostream>
#include <exception>
int main()
{
    using namespace std;

    try
    {
        int* p = new int[1000000000];
    }
    catch (exception& e)
    {
        cout << "misslyckat: " << e.what() ;
    }
}
```

```
#include <iostream>
#include <exception>
int main()
{
    using namespace std;

    try
    {
        int* p = new int[1000000000];
    }
    catch (exception e)
    {
        cout << "misslyckat: " << e.what() ;
    }
}
```

Permalänk: https://www.webforum.nu/p/1001854

## #10 — aasah, 2003-04-06T16:05Z

> **Sang-drax skrev:**
>
> Förtydligande:
> 
> Man **missar** ingenting med att fånga som objekt, men jämför dessa två kodsnuttar så förstår du skillnaden:...

Nej, naturligtvis vill man inte fånga som objekt. 
... 

Ååååh, vad man kan vara korkad ibland! Naturligtvis kan man inte fånga ett kastat objekt med en metod som vill ta en pekare till objektet....  :r ÄNTLIGEN! Den insikten tog två år....  :r (I detta specifika fall har jag inte fattat förrän nu att det är det det handlar om... annars brukar man ju kunna välja om man vill köra med referenser eller pekare....)  :r

Permalänk: https://www.webforum.nu/p/1001905

---

Tråden på webben: https://www.webforum.nu/amne/c-cpp/73279-operatorn-new-undantag-xalloc-fråga