C++ Segmentation fault: 11 Error, while coding linkedlist that adds two numbers

while (l1 || l2)

This means "while either l1 is not nullptr OR l2 is not nullptr, keep looping!

You want an AND there:

while(l1 && l2)

Furthermore, you free all the nodes of your list before you call addTwoNumbers! Move your addTwoNumbers call up to before all the free's.

See it run here: https://ideone.com/f4kBIh

The problem can be fixed easily by replacing malloc with 'new'

Use of 'new' gives these benefits:

• Make the program resilient to common issues with malloc.
• Remove the need for the explicit calls to 'free'.

Here is the working code with malloc replaced by new:

#include <iostream>

struct ListNode {
    int val;
    ListNode *next;
    ListNode() : val(0), next(nullptr){} 
    ListNode(int x) : val(x), next(nullptr){} 
    ListNode(int x, ListNode *next) : val(x), next(next){}
};

void print(ListNode *head) {
    ListNode *l = head;
    while (l) {
        std::cout << "val is " << l->val << std::endl;
        l = l->next;
    }
}

ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
    int sum = 0, quo = 0, rem = 0;
    ListNode *head = new ListNode[(sizeof(ListNode))];
    ListNode *curr, *prev = nullptr;
    while (l1 || l2) {
        // Calculate value
        sum = (l1->val + l2->val + quo);
        quo = sum / 10;
        rem = sum - quo * 10;

        // Add node
        if(prev == nullptr) {
            curr = head;
        } else {
            curr = new ListNode[(sizeof(ListNode))];
            prev->next = curr;
        }
        curr->val = rem;
        prev = curr;
        l1 = l1->next;
        l2 = l2->next;
    }
    return head;
}

int main() {
    ListNode *node1_1 = new ListNode[(sizeof(ListNode))];
    ListNode *node1_2 =  new ListNode[(sizeof(ListNode))];
    ListNode *node1_3 =  new ListNode[(sizeof(ListNode))];
    node1_1->val = 2;
    node1_2->val = 4;
    node1_3->val = 3;
    node1_1->next = node1_2;
    node1_2->next = node1_3;

    ListNode *node2_1 = new ListNode[(sizeof(ListNode))];
    ListNode *node2_2 = new ListNode[(sizeof(ListNode))];
    ListNode *node2_3 = new ListNode[(sizeof(ListNode))];
    node2_1->val = 5;
    node2_2->val = 6;
    node2_3->val = 4;
    node2_1->next = node2_2;
    node2_2->next = node2_3;

    print(addTwoNumbers(node1_1, node2_1));
}

Output:

val is 7
val is 0
val is 8

Ok so some comments about this code

Constructors are great in classes, but if you use C malloc then the constructor is not executed.

Use new and delete for your classes/structs e.g. ListNode, that way next will actually be null as you specify in your constructor, otherwise it will be uninitialized

Your while loop

while (l1 || l2) 

will continue until both are null, but if one of them happens to turn to null you will derereference it since the other is potentially not null:

    l1 = l1->next;
    l2 = l2->next;

(btw use better variable names, there is no advantage using short, cryptic variable names)

In you main function - you have already freed the memory of node1_1 and node1_2 but still use it in your function call print(addTwoNumbers(node1_1,node2_1))

int main() {
    ListNode *node1_1 = (ListNode *)malloc(sizeof(ListNode));
    ListNode *node1_2 = (ListNode *)malloc(sizeof(ListNode));
    ListNode *node1_3 = (ListNode *)malloc(sizeof(ListNode));
    node1_1->val = 2;
    node1_2->val = 4;
    node1_3->val = 3;
    node1_1->next = node1_2;
    node1_2->next = node1_3;

    ListNode *node2_1 = (ListNode *)malloc(sizeof(ListNode));
    ListNode *node2_2 = (ListNode *)malloc(sizeof(ListNode));
    ListNode *node2_3 = (ListNode *)malloc(sizeof(ListNode));
    node2_1->val = 5;
    node2_2->val = 6;
    node2_3->val = 4;
    node2_1->next = node2_2;
    node2_2->next = node2_3;

    free(node1_1);
    free(node1_2);
    free(node1_3);
    free(node2_1);
    free(node2_2);
    free(node2_3);

    print(addTwoNumbers(node1_1, node2_1));  <<== node1_1,node2_1, already freed
}

Instead do something like this

#include <iostream>
int main() {
    auto node1_1 = new ListNode;
    auto node1_2 = new ListNode;
    auto node1_3 = new ListNode;

    node1_1->val = 2;
    node1_2->val = 4;
    node1_3->val = 3;

    node1_1->next = node1_2;
    node1_2->next = node1_3;

    ListNode *node2_1 = new ListNode;
    ListNode *node2_2 = new ListNode;
    ListNode *node2_3 = new ListNode;

    node2_1->val = 5;
    node2_2->val = 6;
    node2_3->val = 4;

    node2_1->next = node2_2;
    node2_2->next = node2_3;

    std::cout << addTwoNumbers(node1_1, node2_1); 

    delete node1_1;
    delete node1_2;
    delete node1_3;
    delete node2_1;
    delete node2_2;
    delete node2_3;
}