No Default Constructor Exists For Class

no default constructor exists for class

If you define a class without any constructor, the compiler will synthesize a constructor for you (and that will be a default constructor -- i.e., one that doesn't require any arguments). If, however, you do define a constructor, (even if it does take one or more arguments) the compiler will not synthesize a constructor for you -- at that point, you've taken responsibility for constructing objects of that class, so the compiler "steps back", so to speak, and leaves that job to you.

You have two choices. You need to either provide a default constructor, or you need to supply the correct parameter when you define an object. For example, you could change your constructor to look something like:

Blowfish(BlowfishAlgorithm algorithm = CBC);

...so the ctor could be invoked without (explicitly) specifying an algorithm (in which case it would use CBC as the algorithm).

The other alternative would be to explicitly specify the algorithm when you define a Blowfish object:

class GameCryptography { 
    Blowfish blowfish_;
public:
    GameCryptography() : blowfish_(ECB) {}
    // ...
};

In C++ 11 (or later) you have one more option available. You can define your constructor that takes an argument, but then tell the compiler to generate the constructor it would have if you didn't define one:

class GameCryptography { 
public:

    // define our ctor that takes an argument
    GameCryptography(BlofishAlgorithm); 

    // Tell the compiler to do what it would have if we didn't define a ctor:
    GameCryptography() = default;
};

As a final note, I think it's worth mentioning that ECB, CBC, CFB, etc., are modes of operation, not really encryption algorithms themselves. Calling them algorithms won't bother the compiler, but is unreasonably likely to cause a problem for others reading the code.

No default constructor exists for class class

If A didn't had its default constructor deleted (by defining any constructor), this code would work. Either you have to call A constructor in initialization list of D.

In case of virtual inheritance, instances of B and C are subobjects of class D, but they don't contain subobject of class A. Instead a single instance of A is subobject of D.

This way there is only one A in D, which solves so called cursed diamond at cost of B,C and D no longer having a standard memory layout ("memcpy-able") even if it didn't had any virtual members and D should have access to constructor of A to be able initialize it.

Error: no default constructor exists for class

When you specify any constructor of your own, the default constructor is not created anymore. However, you can just add it back.

class Dog
    {
    protected:
    string name;
    int age;

    public:

    Dog() = default;

    Dog(string dogsName, int dogsAge)
    {
        name = dogsName;
        age = dogsAge;
    }

    virtual void Bark()
    {
        cout << "Woof Woof I am a dog" << endl;
    }
};

class Huey: public Dog
{
public:

    Huey()
    {
        name = "goodboy";
        age = 13;
    }

     void Bark()
    {
    cout << "woof" << endl;
    }
};

EDIT: It seems like you want to call your custom Dog constructor from Huey. It is done like so

class Dog
    {
    protected:
    string name;
    int age;

    public:

    Dog(string dogsName, int dogsAge)
    {
        name = dogsName;
        age = dogsAge;
    }

    virtual void Bark()
    {
        cout << "Woof Woof I am a dog" << endl;
    }
};

class Huey: public Dog
{
public:

    Huey() : Dog("goodboy", 13) {}

    void Bark()
    {
    cout << "woof" << endl;
    }
};

No default constructor exists for class error

The problem is here:

Stuff(Thing thing) {
    this->thing = thing;
}

By the time you enter the constructor's body, the compiler will have already initialized your object's data members. But it can't initialize thing because it does not have a default constructor.

The solution is to tell the compiler how to initialize it by using an initlizer list.

Stuff(Thing thing) : thing(thing) {
    // Nothing left to do.
}

This is less typing, cleaner code and more efficient. (More efficient, because if the variable is going to be initialized anyway, then why initialize it with an unwanted value first just to assign another one as quickly as you can? Of course, since your current code doesn't even compile, “more efficient” is a somewhat dubious statement, here.)

No default constructor exists for class if I want to construct a class with another one

The problem is that since you have a parameterized constructor for your class Ball, the compiler will not synthesize a default constructor by itself. So if you want to create/construct an object of class Ball using a default constructor, say by writing Ball b;, then you must first provide a default constrcutor for class Ball as shown below.

Solution 1

Just add a default constrctor in class Ball as shown below:

Ball.h

class Ball {
    private:
        Vector3 position;
        Vector3 speed;
        float radius = 0;//use in-class initializer
    public:
        Ball(Vector3 ballPosition, Vector3 ballSpeed,float ballRadius); 
        Ball() = default;   //DEFAULT CONSTRUCTOR ADDED   
};

Alternative Method of adding constructor

Another way of adding a default constructor would be as shown below:

Ball.h

#pragma once
#include <vector>
#include <raylib.h>


class Ball {
    private:
        Vector3 position;
        Vector3 speed;
        float radius = 0;//use IN-CLASS INITIALIZER
    public:
        Ball(Vector3 ballPosition, Vector3 ballSpeed,float ballRadius); 
        Ball(); //declaration for default constrctor      
};

Ball.cpp

#include "Ball.h"
#include <raymath.h>
#include <rlgl.h>

Ball::Ball(Vector3 position, Vector3 speed,float radius) {
    this->position = position;
    this->speed = speed;
    this->radius = radius;

}
//define the default constructor
Ball::Ball()
{
    cout << "default constructor" << endl;
    //do other things here if needed
}

C++: No default constructor exists for parent class

You got it there, Tree does not have a default constructor. As a result of that, you cannot default-construct a BST, because the Tree that is inside it will not know how to construct itself.

You have to member-initialize it.

BST::BST() : Tree(1) {}

Are you sure you don't want to pass that value to the constructor of BST though?

BST::BST(int w) : Tree(w) {}

---

Related Topics