No default instructer exists for (inherited class) c++

Question

Program's purpose: This program's purpose it to create a basic 2d game using only the consol. The program currently only creates a moveable box with the keys "wasd". I'm planning to incorperate bullets, enemy NPC's, barriers, and much more.

Problem: Hello, for some reason my bullet constructor class in my "Bullet.cpp" file is showing up with the error "error C2512: 'BoxClass': no appropriate default constructor available". In "Bullet.h" I have "class Bullet : protected BoxClass". Why am I getting this error?

Other Question(s): Also how should I group my headers? They're getting to become a large cluster.

Comments: I also realize my game loops shouldn't be in the "BoxClass.cpp". I'm going to fix that after I get my bullet class working. If I'm structuring anything else wrong or if you see an easier way of writing some of the same code just let me know.

This is my first graphical game in c++!

ConsolApplication1.cpp:

#include "stdafx.h"
#include <windows.h>
#include "BoxClass.h"
#include "ConsolWindow.h"
#include "Bullet.h"
#include <iostream>

using namespace std;

#define W_KEY 0x57
#define S_KEY 0x53
#define A_KEY 0x41
#define D_KEY 0x44
#define R_KEY 0x52

int main() {
    //variable declaration/definition
    int right_Wall, speed_Var;

    //Consol Size/Position
    int half_screen_Size = (GetSystemMetrics(SM_CXSCREEN)/2);
    Set_Consol_Size(half_screen_Size, GetSystemMetrics(SM_CYSCREEN));
    Position_Consol(-6, 0);

    while (1) {
        cout << "Enter speed of rectangle/box\nSpeed = ";
        cin >> speed_Var;

        BoxClass box1(4, 3);
        box1.Print_Solid_Rectangle();

        cout << "\n\nMove the rectangle with wasd\n\n";


        //Rectangle Movement
        box1.Rectangle_Movement(speed_Var);
    }
    //exit
    return 0;
}

BoxClass.cpp:

#include "stdafx.h"
#include "BoxClass.h"
#include "ConsolWindow.h"
#include <iostream>
#include <math.h>
#include <Windows.h>
using namespace std;

#define W_KEY 0x57
#define S_KEY 0x53
#define A_KEY 0x41
#define D_KEY 0x44
#define R_KEY 0x52

#define _NOT_MOVING 0
#define _MOVING 1

    //Non Moving Rectangle
    void BoxClass::Print_Solid_Rectangle() {
        //calc
        boxSpacesWidth = (3 * recWidth) - 4;

        //draw top of box
        for (width = 1; width < recWidth; width += 1) {
            cout << "...";
        }
        cout << "\n";

        //draw sides
        for (height = 1; height < recHeight; height += 1) {
            cout << ":";
            height_Count++;

            for (width = 1; width < boxSpacesWidth; width += 1) {
                cout << " ";
            }

            cout << ":\n";
        }

        //draw bottom
        cout << ":";

        for (width = 1; width < boxSpacesWidth; width += 1) {
            cout << ".";
        }
        cout << ":\n";
    }

    //Moving Rectangle
    void BoxClass::Print_Rectangle_Moving(int x, int y, int horizontalSpaces, int verticleSpaces) {
        //calc
        boxSpacesWidth = (3 * x) - 4;
        rightWall = ((x-1)*3) + horizontalSpaces;
        retrieveX = (ceil((((x-1)*3)/2))+1)+horizontalSpaces;
        retrieveY = verticleSpaces;
        cout << retrieveY<<endl;

        //New Line
        for (i = 1; i <= verticleSpaces; i += 1) {
            cout << "\n";
        }

        //draw top of box
        for (width = 1; width <= horizontalSpaces; width+=1) {
            cout << " ";
        }

        for (width = 1; width < x; width += 1) {
            cout << "...";
        }
        cout << "\n";

        //draw sides
        for (height = 1; height < y; height += 1) {

            for (width = 1; width <= horizontalSpaces; width += 1) {
                cout << " ";
            }

            cout << ":";
            height_Count++;

            for (width = 1; width < boxSpacesWidth; width += 1) {
                cout << " ";
            }

            cout << ":\n";
        }

        //draw bottom
        for (width = 1; width <= horizontalSpaces; width += 1) {
            cout << " ";
        }

        cout << ":";

        for (width = 1; width < boxSpacesWidth; width += 1) {
            cout << ".";
        }
        cout << ":\n";
    }

    void BoxClass::Rectangle_Movement(int speed) {
        speed_Var = speed;

        //Rectangle Movement
        while (GetAsyncKeyState(VK_ESCAPE) == false) {

            if (GetAsyncKeyState(R_KEY)) {
                system("CLS");
                break;
            }

            if (GetAsyncKeyState(W_KEY)) {
                if (verticleCount > 0) {
                    system("CLS");
                    verticleCount = verticleCount - speed_Var;
                    Print_Rectangle_Moving(recWidth, recHeight, horizontalCount, verticleCount);
                }
            }

            if (GetAsyncKeyState(S_KEY)) {
                system("CLS");
                verticleCount = verticleCount + speed_Var;
                Print_Rectangle_Moving(recWidth, recHeight, horizontalCount, verticleCount);
            }

            if (GetAsyncKeyState(A_KEY)) {
                if (horizontalCount > 0) {
                    system("CLS");
                    horizontalCount = horizontalCount - (speed_Var*2);
                    Print_Rectangle_Moving(recWidth, recHeight, horizontalCount, verticleCount);
                }
            }

            if (GetAsyncKeyState(D_KEY)) {
                if (rightWall < 113) {
                    system("CLS");
                    horizontalCount = horizontalCount + (speed_Var*2);
                    Print_Rectangle_Moving(recWidth, recHeight, horizontalCount, verticleCount);
                }
            }

            if (GetAsyncKeyState(VK_SPACE)) {

            }
        }
    }

    // constructor
    BoxClass::BoxClass(int x, int y) {

        //variable definition
        height_Count = 1;

        speed_Var = 1;
        horizontalCount = 0; 
        verticleCount = 0;

        recWidth = x;
        recHeight = y;
    };

BoxClass.h:

#ifndef BOXCLASS_H
#define BOXCLASS_H


class BoxClass {
    unsigned short int width;
    int height, i, recWidth, recHeight, rightWall;
    float boxSpacesWidth, height_Count;

    int width_Var, height_Var, position_Var;
    int speed_Var = 1;
    unsigned short int horizontalCount = 0, verticleCount = 0;


protected:
    //retrieve values for bullet spawn location
    int retrieveX, retrieveY;

public:
    void Print_Rectangle_Moving(int x, int y, int horizontalSpaces, int verticleSpaces);

    void Print_Solid_Rectangle();

    void Rectangle_Movement(int speed);

    // constructor
    BoxClass(int x, int y);
};

#endif

Bullet.cpp:

#include "stdafx.h"
#include "Bullet.h"
#include <iostream>
#include <Windows.h>

using namespace std;

void Bullet::Bullet_Draw_Collision() {

    for (int height = 1; height <= 2; height+=1) {
        cout << "|\n";
    }

}



Bullet::Bullet() {
}

Bullet.h:

#ifndef BULLET_H
#define BULLET_H

#include "BoxClass.h"

class Bullet : public BoxClass {

public:
    void Bullet_Draw_Collision();

    //constructor
    Bullet();

};
#endif

ConsolWindow.cpp:

#include "stdafx.h"
#include "ConsolWindow.h"
#include <iostream>
#include <Windows.h>
using namespace std;

int Find_Consol_Size() {
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    int columns, rows;

    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
    columns = csbi.srWindow.Right - csbi.srWindow.Left + 1;
    rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;

    return columns;
}

void Set_Consol_Size(int x, int y) {
    HWND console = GetConsoleWindow();
    RECT r;
    GetWindowRect(console, &r);
    MoveWindow(console, r.left, r.top, x, y, TRUE);
}

void Position_Consol(int x, int y) {
    HWND consoleWindow = GetConsoleWindow();
    SetWindowPos(consoleWindow, 0, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}

ConsolWindow.h:

#ifndef CONSOLWINDOW_H
#define CONSOLWINDOW_H

int Find_Consol_Size();
void Set_Consol_Size(int x, int y);
void Position_Consol(int x, int y);

#endif

`Bullet::Bullet()` needs to call a `BoxClass` constructor, but you aren't providing one. It will try to use a default `BoxClass` constructor but there isn't one. — François Andrieux, Mar 28 '18 at 20:16
An example of a [mcve] that duplicates the error [here](https://www.ideone.com/R4cDv5). — PaulMcKenzie, Mar 28 '18 at 20:23
@FrançoisAndrieux Where and how do I put my BoxClass constructor in "Bullet::Bullet()"? — Johnathan Maxwell, Mar 28 '18 at 20:29
@FredLarson I'm not really proficient with pointers and the way that code is written. — Johnathan Maxwell, Mar 28 '18 at 20:34
Maybe this one is a little easier to swallow: https://stackoverflow.com/q/15777635/10077 — Fred Larson, Mar 28 '18 at 20:37
@FredLarson Thank you so much! I added another constructor(a default one with no parameters) to "BoxClass.cpp" and "BoxClass.h" and in "Bullet.cpp" I wrote "Bullet::Bullet() : BoxClass(){}" — Johnathan Maxwell, Mar 28 '18 at 20:49
@JohnathanMaxwell Note that `BoxClass()` isn't needed in this case, it's the default behavior and implied if you don't specify any base constructor at all. Though it isn't wrong to have it. — François Andrieux, Mar 28 '18 at 20:51

François Andrieux · Accepted Answer · 2018-03-28T20:51:57.493

In c++, constructing a derived type implies that both the base and derived portions of the object must be constructed. This is done by calling the base's constructor before the derived type's constructor can begin.

The default behavior is to use the base's default constructor. However you can indicate a different base constructor to use by adding it to the member initialization list and providing appropriate arguments for it.

In your case, notice that a BoxClass only has one constructor which must be provided with an x and y, but a Bullet has no such construction argument. Perhaps some default values such as zeroes or ones might be appropriate, though I suspect you will want to add those arguments to your Bullet class. Here are a few example to illustrate how you could solve the problem.

By asking for construction arguments for Bullet :

class Bullet : public BoxClass 
{
public:
    //constructor
    Bullet(int x, int y);

};

Bullet::Bullet(int x, int y) : 
    BoxClass(x, y) // Indicates which BoxClass constructor to use
{}

By providing arbitrary construction arguments to BoxClass :

class Bullet : public BoxClass 
{
public:
    //constructor
    Bullet();

};

Bullet::Bullet() : 
    BoxClass(1, 1)
{}

Or by adding a default constructor to BoxClass, such as by giving a default value to each of it's existing constructor's arguments :

class BoxClass 
{ 
public:
    // This constructor is now a default constructor
    BoxClass(int x = 1, int y = 1);
};

class Bullet : public BoxClass 
{
public:
    //constructor
    Bullet();

};

Bullet::Bullet() // Uses the default BoxClass constructor
{}

Which solution is best depends on your design goals, but I suspect the first one is likely to be more appropriate.

No default instructer exists for (inherited class) c++

1 Answers1