0Xc0000005: Access Violation Reading Location 0X00000000

0xC0000005: Access violation reading location 0x00000000

This line looks suspicious:

invaders[i] = inv;

You're never incrementing i, so you keep assigning to invaders[0]. If this is just an error you made when reducing your code to the example, check how you calculate i in the real code; you could be exceeding the size of invaders.

If as your comment suggests, you're creating 55 invaders, then check that invaders has been initialised correctly to handle this number.

0xC0000005: Access violation reading location 0x00000000. issues with overloaded == operator

As mentioned in the comments, sizeof(cs_measure::Measure::unitStrings) is not the number of items in the array cs_measure::Measure::unitStrings. It is the number of bytes the array occupies in memories.

Since the size in bytes is almost surely larger than the number of elements, you will access the array out-of-bounds in the loop, causing undefined behavior.

You can get the number of items in a built-in array with

std::size(cs_measure::Measure::unitStrings)

since C++17 (may require #include<iterator> if you have not included any container library header).

Or if you can't use C++17, you can define your own version of it, though the C++17 standard version is a bit more powerful. (from cppreference.com):

template <class T, std::size_t N>
constexpr std::size_t size(const T (&array)[N]) noexcept
{
    return N;
}

Why do I get 0xC0000005: Access violation reading location 0x0000000000000000

MyString()
    :str{nullptr}
{
    str = new char[1];
    //str = '\0'; // <-- here is your mistake
    str[0] = '\0'; // do this instead
}

0xC0000005: Access violation reading location 0x005EF9E4

When you call TerminateThread, you are basically force-crashing your threads. They still have their own stack allocated and handles to Windows resources. They aren't cleaned up properly, causing your crash.

Here's a simple example of how to close your threads without any error. In a real-world scenario this is an unprofessional solution, but it shows the bare minimum that you need to do.

#include <windows.h>
#pragma comment(lib, "Winmm.lib")

volatile bool quit1 = false;
volatile bool quit2 = false;

DWORD WINAPI bytebeat1(LPVOID) {
    while (!quit1) {
        HWAVEOUT hwo = 0;
        WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 11000, 11000, 1, 8, 0 };
        waveOutOpen(&hwo, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);

        char buffer[11000 * 6];

        for (DWORD t = 0; t < sizeof(buffer); t++)
            buffer[t] = static_cast<char>(t & t + t / 256) - t * (t >> 15) & 64;

        WAVEHDR hdr = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
        waveOutPrepareHeader(hwo, &hdr, sizeof(WAVEHDR));
        waveOutWrite(hwo, &hdr, sizeof(WAVEHDR));
        waveOutUnprepareHeader(hwo, &hdr, sizeof(WAVEHDR));
        waveOutClose(hwo);
        Sleep(6000);
    }

    return 0;
}

DWORD WINAPI bytebeat2(LPVOID) {
    while (!quit2) {
        HWAVEOUT hwo = 0;
        WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 8000, 8000, 1, 8, 0 };
        waveOutOpen(&hwo, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);

        char buffer[8000 * 6];

        for (DWORD t = 0; t < sizeof(buffer); t++)
            buffer[t] = static_cast<char>(t, t / 5) >> t / 25 & t / 55 ^ t & 255 ^ (t / 150) ^ 2508025 * 24240835810 & (t / 100) * t / 6000 ^ 5000 * t / 2500 ^ 25 * t / 24;

        WAVEHDR hdr = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
        waveOutPrepareHeader(hwo, &hdr, sizeof(WAVEHDR));
        waveOutWrite(hwo, &hdr, sizeof(WAVEHDR));
        waveOutUnprepareHeader(hwo, &hdr, sizeof(WAVEHDR));
        waveOutClose(hwo);
        Sleep(6000);
    }

    return 0;
}

int main() {
    HANDLE beat1 = CreateThread(0, 0, bytebeat1, 0, 0, 0);
    Sleep(6000);
    quit1 = true;
    WaitForSingleObject(beat1, INFINITE);
    CloseHandle(beat1);
    Sleep(1000);
    HANDLE beat2 = CreateThread(0, 0, bytebeat2, 0, 0, 0);
    Sleep(6000);
    quit2 = true;
    WaitForSingleObject(beat2, INFINITE);
    CloseHandle(beat2);
}

Don't Understand Why I am Getting Exception: Access violation reading location 0x00000000

Your problem is that

• length() need memberString to return size of stored data,
• memberString need length() to be created.

I think that your constructor should not rely on other member function.

What about:

MyString::MyString(const char* aString) //memberString is a    c-string object
{
    memberString = new char[strlen(aString) + 1];
    strcpy(memberString, aString);
}

Exception thrown at 0x00000000 in CobwebDiagram.exe: 0xC0000005: Access violation executing location 0x00000000

gladLoadGLLoader((GLADloadproc)glfwGetProcAddress) needs to be called before the very first OpenGL instruction. Call it right after glfwMakeContextCurrent(window):

glfwMakeContextCurrent(window);
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
    cout << "Failed to initialize GLAD" << endl;
    return -1;
}

There is also a problem in your shader code. A semicolon is missing at the end of lineColor = vec4(1.0f, 0.1f, 0.2f, 1.0f). I suggest using raw string literals:

const char* fragmentShaderSource = R"(
      #version 330 core
      out vec4 lineColor;
      void main()
      {
          lineColor = vec4(1.0f, 0.1f, 0.2f, 1.0f);
      }
)";

Access violation reading location 0x00000000. 'new' keyword?

0xC0000005: Access violation reading location 0x00000000.

This means you're dereferencing a null pointer, likely in the constructor of Bar, or in some other code called by this constructor. Use a debugger to determine exactly where.

---

Related Topics