Access variable in "main.cpp" from other classes

[Xillez]

Hey, How do you access a variable in main.cpp from a class?

So if I want to get access to "board" how would I do so?

 
main.cpp:
 
Boxes board[10];
 
Boxes.h: 
 
void displayBox(int instance);
 
Boxes.cpp:
 
void displayBox(int instance)
{
    glBegin(GL_POLYGON);
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)),                (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)));
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize, (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)));
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize, (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize);
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)),                (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize);
    glEnd();
}
 
 

[weaknessforcats]

I may not have this right but it looks like color is a property of Boxes. So I added a color property. See boxes.h below.

This is the main();

#define  _CRT_SECURE_NO_WARNINGS
 
#include <iostream>
using namespace std;
 
 
 
//main.cpp:
 
#include "Boxes.h"
#include "func.h"
 
int main()
{
 
    Boxes board[10];
 
    DisplayBox(board[3]);
 
}
 

The compiler will need to know about Boxes and the DisplayBox function. So there is a Boxes.h and a func.h.

// Boxes.h
#ifndef BOXES
#define BOXES
class Boxes
{
    int color;
public:
 
    void SetColor(int arg) { this->color = arg; }
    int  GetColor() { return this->color; }
 
 
 
};
#endif
 
//func.h
 
#ifndef FUNCH
#define FUNCH
 
#include "Boxes.h"
void DisplayBox(Boxes& arg);
 
#endif
 

Finally the functions are in their own file but here the compiler needs to know about Boxes:

// func.cpp
#include <iostream>
using namespace std;
 
#include "Boxes.h"
 
void DisplayBox(Boxes& arg)
{
    cout << arg.GetColor();
}

Is this what you had in mind?

[Oralloy]

You can just write this into boxes.cpp

extern Boxes board[10];

[Xillez]

Didn't work Oralloy.

Sorry, I forgot to add "float color[3] = {1.0f, 1.0f, 1.0f};" to Boxes.h. I just moved the functions I needed "board[]" in to the "main.cpp" file. Here is my entire code with a separate problem...

In this project I make a window with some squares. When you click on one of these squares it should toggle it's color. BUT for some reason it wont change color, but it registered and found out that I clicked on it...

My guess is that it's an instance flaw or "color[3]" (in Boxes.h) is a global value, which it shouldn't be because it isn't static.

What is causing this flaw?

main.cpp:

#include <windows.h>
#include <gl/gl.h>
#include "Boxes.h"
 
LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
void DisableOpenGL(HWND, HDC, HGLRC);
 
const int wWidth = 1080 + Boxes::space;
const int wHeight = 724 + Boxes::space;
const int nrBoxX = 2; //max = 45
const int nrBoxY = 2; //max = 30
const int nrBoxT = 4; //max = 1350
Boxes board[4];
POINT mousePt;
int mouseX = 0;
int mouseY = 0;
bool isBoxesSetup = false;
 
void setupBox()
{
    int a = 0;
    for (int y = 0; y < nrBoxY; y++)
    {
        for (int x = 0; x < nrBoxX; x++)
        {
            board[a].xPosition = x;
            board[a].yPosition = y;
            a++;
        }
    }
    isBoxesSetup = true;
}
 
void displayBox(int instance)
{
    glBegin(GL_POLYGON);
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)),                (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)));
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize, (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)));
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize, (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize);
        glColor3f(board[instance].color[0], board[instance].color[1], board[instance].color[2]); glVertex2i((int) Boxes::space + (board[instance].xPosition * (Boxes::bSize + Boxes::space)),                (int) Boxes::space + (board[instance].yPosition * (Boxes::bSize + Boxes::space)) + Boxes::bSize);
    glEnd();
}
 
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
    WNDCLASSEX wcex;
    HWND hwnd;
    HDC hDC;
    HGLRC hRC;
    MSG msg;
    BOOL bQuit = FALSE;
 
    /* register main window class */
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_OWNDC;
    wcex.lpfnWndProc = WindowProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = "All White";
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
 
 
    if (!RegisterClassEx(&wcex))
        return 0;
 
    /* create main window */
    hwnd = CreateWindowEx(0,
                          "All White",
                          "All White",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          wWidth,
                          wHeight,
                          NULL,
                          NULL,
                          hInstance,
                          NULL);
 
    ShowWindow(hwnd, nCmdShow);
 
    /* enable OpenGL for the window */
    EnableOpenGL(hwnd, &hDC, &hRC);
 
    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                bQuit = TRUE;
            }
            else
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else
        {
            /* OpenGL animation code goes here */
 
            glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            glClear(GL_COLOR_BUFFER_BIT);
 
            glPushMatrix();
 
            glOrtho(0, wWidth, wHeight, 0, -1, 1);
 
            if (!isBoxesSetup) setupBox();
 
            for (int a = 0; a < nrBoxT; a++)
            {
                displayBox(a);
            }
 
            glPopMatrix();
 
            SwapBuffers(hDC);
        }
    }
 
    /* shutdown OpenGL */
    DisableOpenGL(hwnd, hDC, hRC);
 
    /* destroy the window explicitly */
    DestroyWindow(hwnd);
 
    return msg.wParam;
}
 
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CLOSE:
            PostQuitMessage(0);
        break;
 
        case WM_DESTROY:
            return 0;
        break;
 
        case WM_LBUTTONDOWN:
            GetCursorPos(&mousePt);
            ScreenToClient(hwnd, &mousePt);
            mouseX = mousePt.x;
            mouseY = mousePt.y;
            for (int i = 0; i < nrBoxT; i++)
            {
                bool buttonPressed = board[i].checkIfPressed(mouseX, mouseY);
                if (board[i].checkIfPressed(mouseX, mouseY))
                {
                    board[i].toggleColorState(i);
                }
            }
        break;
 
        case WM_KEYDOWN:
        {
            switch (wParam)
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                break;
 
                case VK_SPACE:
                    PostQuitMessage(0);
                break;
            }
        }
        break;
 
        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
 
    return 0;
}
 
void EnableOpenGL(HWND hwnd, HDC* hDC, HGLRC* hRC)
{
    PIXELFORMATDESCRIPTOR pfd;
 
    int iFormat;
 
    /* get the device context (DC) */
    *hDC = GetDC(hwnd);
 
    /* set the pixel format for the DC */
    ZeroMemory(&pfd, sizeof(pfd));
 
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
                  PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
 
    iFormat = ChoosePixelFormat(*hDC, &pfd);
 
    SetPixelFormat(*hDC, iFormat, &pfd);
 
    /* create and enable the render context (RC) */
    *hRC = wglCreateContext(*hDC);
 
    wglMakeCurrent(*hDC, *hRC);
}
 
void DisableOpenGL (HWND hwnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hRC);
    ReleaseDC(hwnd, hDC);
}
 

Boxes.h:

#ifndef BOXES_H
#define BOXES_H
 
class Boxes
{
    public:
        float color[3] = {1.0f, 1.0f, 1.0f};
        const static int space = 4;
        const static int bSize = 20;
        int xPosition = 0;
        int yPosition = 0;
        int realMinX = (int) space + (xPosition * (bSize + space));
        int realMaxX = (int) space + (xPosition * (bSize + space)) + bSize;
        int realMinY = (int) space + (yPosition * (bSize + space));
        int realMaxY = (int) space + (yPosition * (bSize + space)) + bSize;
        int cState = 3;
        int nState = 0;
 
        Box(int xPos, int yPos);
        float getColor();
        void setColor(float red, float green, float blue);
        void toggleColorState(int i);
        bool checkIfPressed(int x, int y);
 
    protected:
 
    private:
 
};
 
#endif // BOXES_H
 
 

Boxes.cpp:

#include "Boxes.h"
#include <windows.h>
#include <gl/gl.h>
 
extern Boxes board[4];
 
Boxes::Box(int xPos, int yPos)
{
    xPosition = xPos;
    yPosition = yPos;
}
 
void Boxes::toggleColorState(int i)
{
    cState = nState;
    nState++;
    if (nState > 3) nState = 0;
 
    if (cState == 0)
    {
        board[i].color[0] = 1.0f;
        board[i].color[1] = 0.0f;
        board[i].color[2] = 0.0f;
    }
    if (cState == 1)
    {
        board[i].color[0] = 0.0f;
        board[i].color[1] = 1.0f;
        board[i].color[2] = 0.0f;
    }
    if (cState == 2)
    {
        board[i].color[0] = 0.0f;
        board[i].color[1] = 0.0f;
        board[i].color[2] = 1.0f;
    }
    if (cState == 3)
    {
        board[i].color[0] = 1.0f;
        board[i].color[1] = 1.0f;
        board[i].color[2] = 1.0f;
    }
}
 
//Not used
float Boxes::getColor()
{
    return *color;
}
 
//Not used
void Boxes::setColor(float red, float green, float blue)
{
    color[0] = red;
    color[1] = green;
    color[2] = blue;
}
 
bool Boxes::checkIfPressed(int x, int y)
{
    if (x > realMinX && x < realMaxX && y > realMinY && y < realMaxY) return true;
    return false;
}
 
 

[weaknessforcats]

You cannot put any code in a header file that creates variables or that is code for the body of a function. Every time the .h is included by the various .cpp files you get another set of variables. Then your build dies in the link with redefinition errors.

Instead use a #define in your include:

#define RED 1.0
#define BLUE  2.0
 

There should never be any hard-coded symbolic constants in your code. A symbolic constant is like 4 or 25.2, etc...

What is this?????

void Boxes::toggleColorState(int i)
14. {
15.     cState = nState;
16.     nState++;
17.     if (nState > 3) nState = 0;
18. 
19.     if (cState == 0)
20.     {
21.         board[i].color[0] = 1.0f;
22.         board[i].color[1] = 0.0f;
23.         board[i].color[2] = 0.0f;
24.     }
 

This is class member function. There is no board variable possible. board is an array in main(). There is no variable i The code I sent you uses board only in main().

Also, your class should have no public data members. This is not a C struct but a C++ class. Any color values should be defined in the header file as above, or you will need a Color class that has a private obj in Boxes.

Remember, all the processing is in main(). All the class member functions do is manage the private data members of the class.

It looks like you are merging the application code with the class code and this will never work.

main.cpp:
 
Boxes board[10];
 
      board[1].setColor(etc...};

This code changes the Boxes object board[1]. Inside the member function all you have is the address of the board object which is calling the member function. Read up on the this pointer.

keep posting . We have all gone through this.

[donbock]

It isn't that you can't put variable or function definitions in a header file -- it's that it is almost always a mistake to do so. Sometimes doing so triggers a build error, other times it may yield a possibly intermittent run-time bug.

Typically, you put a variable or function definition in one .c/.cpp file and the corresponding declaration in a header file that is included by all .c/.cpp files that define or refer to that variable or function.