new вызывает std::bad_alloc

//main.c
#include "stdafx.h"
#include "whirlpool.h"

int _tmain(int argc, _TCHAR* argv[])
{
    whirlpool a(6), c(4);
    a.buffer[0]=0, a.buffer[1]=1, a.buffer[2]=1, a.buffer[3]=0, a.buffer[4]=1, a.buffer[5]=1;
    c.buffer[0]=1, c.buffer[1]=0, c.buffer[2]=0, c.buffer[3]=1;
    a.gf8mul(a, c);
    system("pause");
   return 0;
}

//whirlpool.cpp
#include "stdafx.h"
#include "whirlpool.h"

using namespace std;

bool whirlpool::isnull(whirlpool a)
    {
    int i;
    for (i=0; i<a.len; i++)
    {
        if (a.buffer[i]&1)
            return false;
    }
    return true;
    }

whirlpool whirlpool::operator<< (int k)
    {
        int i=0, j=0, old_len=len;
        int *temp = new int[len];
       
        for (i=0; i<old_len; i++)
            temp[i] = buffer[i];
        //удалить buffer
        buffer = new int[old_len+k];
        len=old_len+k;

        for (i=0; i<k; i++)
           buffer[i]=0;

        for (i=k; i<len; i++)
           buffer[i]=temp[i-k];

    return *this;
    }

whirlpool whirlpool::operator>> (int k)
    {
        int i, j;

        for (j=0; j<k; j++)
        {
            for (i=1; i<len; i++)
               buffer[i-1]=buffer[i];

            buffer[len-1]=0;
        }
        len=len-k;
        return *this;
    }

whirlpool whirlpool::operator=(whirlpool a)
{
    int i=0;
    len=a.len;
    for (i=0; i<len; i++)
        buffer[i]=a.buffer[i];

    return *this;
}

whirlpool operator^(whirlpool a, whirlpool b)
{
    int i, min_len=0, max_len=0;
    whirlpool temp,_a,_b;
    _a=a;
    _b=b;

    if (_a.len>_b.len)
    {
        min_len=_b.len;
        max_len=_a.len;

        for (i=0; i<min_len; i++)
            _a.buffer[i]=_a.buffer[i]^_b.buffer[i];

        temp=_a;
    } else
        {
            min_len=_a.len;
            max_len=_b.len;

        for (i=0; i<min_len; i++)
            _b.buffer[i]=_b.buffer[i]^_a.buffer[i];
       
        temp=_b;
        }
   
    i=temp.len-1;
        while(i>0)
        {
            if(temp.buffer[i]==0)
            {
                temp.len--;
            }
            if(temp.buffer[i]==1)
            {
                i=0;
            }
            i--;
        }

    return temp;
}



    whirlpool whirlpool::gf8mul(whirlpool a, whirlpool b)
    {
    int i=0;
    whirlpool _a;
    whirlpool _b;
    _a=a;
    _b=b;
    whirlpool c(a.len);
    for (i=0; i<c.len; i++)
    c.buffer[i]=0;
   
    const whirlpool pol2(9);
    pol2.buffer[0]=1, pol2.buffer[1]=0, pol2.buffer[2]=1, pol2.buffer[3]=1, pol2.buffer[4]=1, pol2.buffer[5]=0, pol2.buffer[6]=0, pol2.buffer[7]=0, pol2.buffer[8]=1;
   
    while (isnull(_b) == false)
    {
        if (_b.buffer[0]& 1)
        {
            c = c^_a;
        }
       
        _b = _b >> 1;
        _a = _a << 1;

        if (_a.len > 8)
        {
            _a = _a^pol2;//0x11d=100011101
        }
    }

    return c;
    }

//whirlpool.h
#pragma once
#include <iostream>
#include <fstream>
#include <iostream>

using namespace std;

class whirlpool
{
public:

    int *buffer;
    int len;
   
    whirlpool()
    {
        len=1;
        buffer = new int[len]; //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!здесь ошибка std::bad_alloc
    }

    whirlpool(int length)
    {
        len = length;
        buffer = new int[len];
    }
   
bool isnull(whirlpool);
whirlpool operator=(whirlpool);
whirlpool operator<< (int);
whirlpool operator>> (int);
friend whirlpool operator^(whirlpool,whirlpool);
whirlpool gf8mul(whirlpool, whirlpool);
~whirlpool()
{
}
};