Yet another STL:bad_alloc Issue

int main(){	Sphere* s1 = new Sphere(0.0,0.0,0.0,2.0,new Material(1.0,0,0,0.5,0.5,1.33));	Line* l1 = new Line(3,1,0,-1,0,0,1.0);	printf("Incoming Line:\n    %s\n",l1->toString());	CollisionPacket* cp;		cp = s1->getIntersectionRays(l1);	if(cp != NULL){		if(cp->getCollisionPoint() != NULL){			printf("%s ->> Collision Point\n",cp->getCollisionPoint()->toString());		}		if(cp->getReflectLine() != NULL){			printf("Reflection Line:\n    %s\n",cp->getReflectLine()->toString());		}		if(cp->getTransmitLine() != NULL){			printf("Refraction Line:\n    %s\n",cp->getTransmitLine()->toString());		}	}	return 0;}

struct vec3 {  float x, y, z;  // A full suite of arithmetic overloads can go here. I'm only showing the  // ones that I will actually use.  float squaredMagnitude() { return x*x + y*y + z*z; }  vec3& operator-=(const vec3& other) {    x -= other.x; y -= other.y; z -= other.z;    return *this;  }};inline vec3 operator-(const vec3& lhs, const vec3& rhs) {  return (vec3(lhs) -= rhs);}inline float dot(const vec3& lhs, const vec3& rhs) {  return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;}std::ostream& operator<<(std::ostream& os, const vec3& v) {  os << "(" << v.x << ", " << v.y << ", " << v.z << ")";}// Now we go and replace i,j,k of Line.r0, x,y,z of Line.p0, etc. with// vec3s, and do:CollisionPacket Sphere::getIntersectionRays(const Line& l) {  float a = l.r0.squaredMagnitude();  float b = 2.0*(dot(l.r0, l.p0 - position));  // where "position" is the vec3 put together from (x0, y0, z0) which I  // assume are Sphere members. By the way, why be so sparing with your  // variable names?   float c = (l.p0 - position).squaredMagnitude();  float discriminant = b*b-4*a*c;  float t;  // Get the smallest positive root.  if (discriminant < -ZERO) {    t = -1; // we'll check after the if-condition, in one place, to ensure    // we found a positive root.  } else if (discriminant <= ZERO) {    // This is an ELSE if, so we already *know* the discriminant is >= -ZERO.    t = -b / (2*a);  } else {    // We know the discriminant is > ZERO, which makes the sqrt valid and    // positive. Also, since a is a squaredMagnitude, it is positive. We are    // forced to conclude that (using the old values) t0 > t1 always.    t = (-b - sqrt(disc)) / (2*a);    if (t < 0) {      // then try the larger root. If it's still negative, we'll catch that      // at the end.      t = (-b + sqrt(disc)) / (2*a);    }  }  if (t < 0) {    return CollisionPacket::NO_COLLISION;    // Some special instance of the class representing a non-collision.  }    // You used to calculate some variables "x, y, z" here, but didn't use them.  // Uh? You already had a Point class, but seemed not to be using it for  // all kinds of things it could be used for, and also put a bulky interface  // on it?  vec3 collisionPoint = l.getPointAtTime(t);  // Behold, modern C++ I/O.  streamsize oldPrecision = std::cout.precision();  cout.precision(2);  std::cout << "Collision at " << collisionPoint;  // That's the point (pun intended) of the helper operator<< above.  // And similarly a Vect class that's also just a triple of points. There are  // ways to make these as separate classes wrapping around the base vec3  // implementation while maintaining type safety, but for simplicity:  vec3 unitNormal = (collisionPoint - position) / radius;  float transparency = mat.transparency();  Line transLine; // leave as a default object if we are opaque.  if (transparency > 0.0) {    // application of snell's law    // Don't violate the 'Law of Demeter'. Use delegation here instead:    // Have the Line implement getRefraction by delegating to its material    // or returning a default if there is none).    vec3 incident = -l.r0.normalized();    // The negation here takes care of that weird setI/J/K logic you had.    // By the way, don't you think it's a bit strange to have a mutator for    // a public member?    vec3 s1 = unitNormal * dot(unitNormal, incident) - incident;     vec3 s2 = s1 * (l.getRefraction() / mat.getRefraction());    transLine = Line(collisionPoint, s2 - unitNormal,                      l.intensity() * transparency);    // Unless you can show me that getLastMaterial and setLastMaterial do more    // than a direct get/set, I will be telling you to use a public member.    // Sorry, but the alternative is adding extra code that won't really     // protect you or create a meaningful abstraction.    transLine.lastMaterial = mat;  }  Line reflLine; // Leave as default object if material is non-reflective.  float reflectivity = mat.reflectivity();  if (reflectivity > 0.0){    reflLine = Line(collisionPoint, l.r0.findReflection(unitNormal),                     l.intensity * reflectivity);    reflLine.lastMaterial = l.lastMaterial;  }  return CollisionPacket(collisionPoint, transLine, reflLine);}