C++ Access Violation Reading Location 0Xcdcdcdcd Error on Calling a Function

C++ Access violation reading location 0xcdcdcdcd error on calling a function

ptr is a pointer to a myClass, but you don't seem to ever initialize it. In other words, ptr isn't pointing to anything. It's uninitialized -- pointing in to hyperspace.

When you try to use this uninitialized pointer,

ptr->bubSort(...);

You get Undefined Behavior. You're actually lucky that the application crashed, because anything else could have happened. It could have appeared to work.

To fix this problem directly, you need to initialize ptr. One way:

class sampleClass
{
public:
  sampleClass()
  :
    ptr (new myClass)
  {
  }
};

(For an explanation about the funky : syntax, look up "initialization list")

But this uses dynamic allocation, which is best avoided. One of the main reasons why dynamic allocation is best avoided is because you have to remember to delete anything you new, or you will leak memory:

class sampleClass
{
public:
  ~sampleClass()
  {
    delete ptr;
  }
};

Ask yourself if you really need a pointer here, or would doing without be ok?

class sampleClass
{
public:
  myClass mMyClass;
};

sampleClass::func(...)
{
  mMyClass.func();
}

Access violation reading location 0xcdcdcdcd. C++

The variable char name[20] is not valid after leaving the first for()

You should copy the value of the array in the constructor to an array inside Champion or dynamically allocate memory for the name.

This is one option:

#include <stdio.h>
#include <string.h>

class Champion {
  char name[20];

 public:

 Champion(const char theName[],int size ){

  for( int i=0;i < size; i++ ){
    name[i] = theName[i];
  }
 }
 const char* getName(){
  return name;
 }
};

int main(int argc, const char* argv[]){

 Champion *c;
 const char name[] = "vamos";
 c = new Champion(name,strlen(name));
 printf("%s",c->getName());
 return 0;
}

0xC0000005: Access violation reading location 0xCDCDCDCD

Your insert code seems to assume that Node::leftNode and Node::rightNode are initialised to nullptr but your constructor doesn't ensure that. Try this

Node(Key k, Value v)
{
    key = k;
    value.push_back(v);
    leftNode = rightNode = nullptr;
}

Access violation reading location 0xCDCDCDD1

1. Change:

   ISingleNode *temp1 = (ISingleNode *)malloc(sizeof(SingleList));
   

   into:

   ISingleNode *temp1 = new SingleList;
   

2. You are accessing a NULL pointer:

   head = NULL; // set to NULL
   temp1->setValue(value);
   temp1->setNext(head->getNext()); // oops!
   

   you probably meant:

   void SingleList::addHead(int value)
   {
       ISingleNode *temp1 = new SingleList;
       temp1->setValue(value);
       temp1->setNext(head);
       head = temp1;
   }
   

Access violation reading location 0xCDCDCDCD

1. An value in uninitialized buffer allocated via malloc() is assigned to newNode->edge in newNode->next = myGraph.edges[i];.
2. The newNode is set to current via myGraph.edges[i] = newNode; and EdgeList current = myGraph.edges[i];.
3. Assuming that malloc() succeeded, current isn't NULL here, so it is entering the loop.
4. The uninitialized value assinged in 1 is assigned to current in current = current->next;.
5. An undefined behavior is invoked by using value in buffer allocated via malloc() and uninitialized at current != NULL.

To fix this error, initialize myGraph.edges in, for example, this way:

myGraph.edges = (EdgeList*)malloc(myGraph.V*sizeof(EdgeList));
for (int i = 0; i < myGraph.V; i++)
{
    myGraph.edges[i] = NULL;
}

Also, remove the harmful casts to int of the pointer returned from malloc(). Casting the return values to pointers explicitly is also not considered as good.

Unhandled exception Access violation writing location 0xCDCDCDCD - in Structure C++

Your structure contains a std::string element. That is a type that needs its constructor to be executed when that object is created.

You cannot create your struct with malloc because that C function doesn't know about constructors.

The C++ new and delete expressions will do the correct thing. Of course, you should really prefer using smart pointers instead of manual memory management (or no dynamic allocation at all).

The quick way to fix your code is to use new and delete:

ABC *abc = new ABC;
...
delete abc;

---

Related Topics