Unnecessary member variables

You have a member variable curr that has no purpose as a member variable, because it is only used as a temporary pointer to iterate through your list. You should make curr simply be a local variable in the functions it is used in.

The member variable temp is never used and should be deleted.

\$O(n)\$ add

Your addNode function takes linear time because it has to find the end of the list. You should either add to the beginning of the list, or keep a tail pointer so that you can quickly add to the tail.

The main issue you have, and which is in fact the most common issue, is memory management. As it stands, your List class is a huge crash waiting to happen (or worse).

Thus let us first focus specifically on proper memory management. I will assume a modern compiler (>= 2011) and thus the C++11 version of C++ (at least).

Note: Code Review related comments will be preceded by "CR: ", and are unnecessary in "real code". The comments without "CR: " however are comments that help future readers and should remain.

#include <memory> // CR: std::unique_ptr<T> is there

class List {
public:
    List();
    void pushBack(int value); // CR: users don't care about "nodes"
                              // CR: but care about position.
    void print() const;   // CR: List::printList is redundant

private:
    // CR: Implementation details (private stuff) go last,
    // CR: because users don't care about them.

    // CR: C++ style declaration
    // CR: Stripped off unnecessary (and unused) members
    struct Node {
        Node(int v);

        int value;
        std::unique_ptr<Node> next;
    };

    // A single member is needed,
    // but as an optimization we keep a pointer to the tail.
    std::unique_ptr<Node> head;
    Node* tail;
};

The unique_ptr is a new C++11 utility, which takes care of correctly calling the destructor of your item (and thus free the memory, in your case).

List::List(): head(), tail() {}

List::Node::Node(int v): value(v), next() {}

It is a good practice to initialize all data members (even those which would not require it), as this means getting into the habit of initializing them and also avoids wondering later "do I need or do I not?" => don't make me think!

void List::pushBack(int value) {
    // Check for empty list
    if (this->tail == nullptr) {
        this->head.reset(new Node(value));
        // C++14 alternative: this->head = std::make_unique<Node>(value);

        this->tail = this->head.get();

        // CR: early return => keep flow linear
        return;
    }

    this->tail->next.reset(new Node(value));
    // C++14 alternative: this->tail->next = std::make_unique<Node>(value);

    this->tail = this->tail->next.get();   
}

It is a good practice to avoid nesting and sprawling code blocks, by returning early we keep the flow linear. Thus, check for edge cases at the start:

• it makes it easier to check whether they are handled (or not).
• it makes it easier to read the code: a computer is good at handling context (and restoring the previous context when getting to the end of a block) but your brain isn't.

Note that keeping the flow linear reduces the Cyclomatic Complexity of the function, that is, the number of potential execution paths. The less execution paths possible, the easier it is to understand a function purpose and check its correctness.

Note: C programmers advocate Single Entry Single Exit (SESE) because they have to handle resources (such as allocated memory) manually, and having a single exit make it easier to check that all resources are properly disposed off before exiting (and make it easier not to forget to dispose when adding a resource or an exit). In C++, since resources should NEVER be manually disposed off, SESE is unnecessary, and therefore we instead strive for clarity.

void List::print() const {
    for (Node* current = this->head.get(); current; current = current->next.get()) {
        std::cout << " " << current->value << "\n";
    }
}

The function should be const as it does not modify the List.

A for loop is better than a while loop in that it summarizes all the loop-related stuff in one place (initialization, iteration, exit) making it easier to check all those in one fell swoop... as a corollary, weird loops (those happen too) should be expressed as while loops, immediately alerting the reader that they are special (and deserve special attention).

There is no need to use endl, and indeed it is better not to in general. While its name means end of line, what endl does it actually more subtle:

• it adds an end of line character
• it calls .flush() on the stream, ensuring the output is fully transferred (to either disk or screen or ...)

The latter is generally completely unnecessary.

Note: C++ streams are complex beasts, and will actually transform \n to the OS-specific end of line markers, thus \r\n on Windows, automatically.