Runtime error member access within null pointer of type

asked Jun 24, 2017 at 7:31

You only make sure that runner->next is not null, however after assignment

runner = runner->next->next;

runner can become null.

answered Jun 24, 2017 at 7:36

This should solve it:

bool hasCycle(ListNode *head) {
    if(head == NULL || head->next == NULL) { return false; }
    struct ListNode * walker = new ListNode(1);
    struct ListNode * runner = new ListNode(2);
    walker = head;
    runner = walker->next;
    while(walker != fast){
        if(runner == NULL || runner->next == NULL) { return false; }
        walker = walker->next;
        runner = runner->next->next;
    }
    return true;
}

answered Aug 5, 2020 at 3:02

//- If a loop from circular path then there is hundred% chance that they will going to meet at some point so here we are taking a walker which move one step and a runner which move two step.

bool hasCycle(ListNode *head){
if(head == NULL || head->next == NULL)
       return false; 

struct ListNode *temp  = head; 
struct ListNode *walker; 
struct ListNode *runner;
walker = runner= head;
while(temp ){
  walker = walker->next;
  runner = runner->next->next;
    if(runner == walker) // as soon both get at same address we got return as 
     true value.
     { return True; }
    temp = temp->next;
}
return false;

}

answered Aug 21, 2020 at 8:03

answered Jun 13, 2021 at 18:22

Sort answer is here with explanation

It returns the error because runner=runner->next->next can be NULL
and you are checking runner->next!=NULL in while conditioning so you
have to do a little change In your code In order to get your answer In
while condition check for runner->next->next!=NULL and get the right
answer.

Happy Coding :>)

answered Jul 25, 2021 at 13:22

bool alloc_memory(node *n)

Your parameter n is an independent variable, initialised to whatever you pass to alloc_memory. So any changes to n won’t be reflected in the calling code.

There are at least two common ways around:

1. Return the pointer, not a boolean. If the pointer returned is NULL, you know something went wrong.
2. Make the parameter a pointer to pointer to node. That way, you pass the memory address of your pointer you want to have pointing to the new node. The pointer to pointer is still a copy, but the pointee is not.

And I guess you don’t need char chars[N];.

Edit: Some examples what this could look like

1. Function:

   node *make_node() {
       node *new_node = malloc(sizeof(node));
       if (new_node) {
           // initialise the node
       }
       return new_node;
   }
   

   Calling code:

   node *my_new_node = make_node();
   if (!my_new_node) {
       // something's going terribly wrong
   }
   

2. Function:

   bool make_node(node **node_ptr) {
       node *new_node = malloc(sizeof(node));
       if (new_node) {
           // initialise the node
   
           *node_ptr = new_node;
           return true;
       } else {
           return false;
       }
   }
   

   Calling code:

   node *my_new_node;
   if (!make_node(&my_new_node)) {
       // something's going terribly wrong
   }
   

answered Feb 17, 2019 at 16:19

Hello there!

So if you dereference a null pointer accessing a function of class for example like:

SomeClass *p = nullptr;
p->DoSomething();

This can work perfectly fine as long as the function doesn’t touch member variables.

Or even worse something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <iostream>

int g_iGlobalInt = 0;
float g_flGlobalFloat = 0.0f;

class Test
{
public:

	void SetFloatAndInt()
	{
		// m_p is uninitialized, and 'this' is nullptr
		m_p->SetInt();
		m_p->SetFloat();
	}

protected:

	void SetInt()
	{
		g_iGlobalInt = 378;
	}

	void SetFloat()
	{
		g_flGlobalFloat = 222.0f;
	}

private:
	Test *m_p;
};

int main()
{
	Test *p = nullptr;
	p->SetFloatAndInt();

	std::cout << "g_iGlobalInt is: " << g_iGlobalInt << std::endl;
	std::cout << "g_flGlobalFloat is: " << g_flGlobalFloat << std::endl;
	std::cin.get();

	return 0;
}

Which CAN work due to compiler optimization. (Like building in Release mode, this would crash in Debug mode)

To me this is kind of garbage and it can make it harder to track down the actual cause of a crash because there’s some operation done on a bogus pointer somewhere which can be caused by accessing a null pointer like in the example above.

To me if the above behavior is working, that is bad, that is most definitely not something I want.

This is sort of platform specific as far as I know, but I figured I’d ask anyway.

Is there any way to better guarantee desired behavior? I would like it to crash.

GCC and Clang has -fsanitize=null which will add checks for null pointers.

test.cpp:36:19: runtime error: member call on null pointer of type ‘struct Test’
test.cpp:13:3: runtime error: member access within null pointer of type ‘struct Test’

https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#index-fsanitize_003dnull

This option enables pointer checking. Particularly, the application built with this option turned on will issue an error message when it tries to dereference a NULL pointer, or if a reference (possibly an rvalue reference) is bound to a NULL pointer, or if a method is invoked on an object pointed by a NULL pointer.

Wrapping it in my own pointer class wouldn’t be feasible with an existing rather large application in terms of the codebase.

It’s also built with the Microsoft C++ compiler, though I have been interested in clang. I have no idea how difficult it would be to switch everything over. But seeing things like clang-tidy has got me sort of interested.