C++空值和this指针

Question

I'm a newbie in C++, trying to study C++. I have a block of code in Java like this:

public List<String> getDiagnosticTroubleCode() {
    if (diagnosticTroubleCode == null) {
        diagnosticTroubleCode = new ArrayList<String>();
    }
    return this.diagnosticTroubleCode;
}

How can I compare the disgnosticTroubleCode with null value? and set it as a new List . I already override the std::list to make it use like List in Java. And then I want to return the diagnosticTroubleCode field within the object this . I hope that you guys can help me with this. Trying to study about this pointer and null .

Here is my header in C++ :

class RUNTIME_EXPORTS DiagnosticTroubleCode {
            protected:
                List diagnosticTroubleCode;
            public:
                List getDiagnosticTroubleCode();
            };

Answer 1

Your code appears to desire only instantiating diagnosticTroubleCode on first use. Frankly, I find that somewhat odd, since an instance of an otherwise-empty std::list<std::string> would be rather benign. Regardless, this is one way to do that.

class DiagnosticTroubleCode 
{
protected:
    std::unique_ptr<std::list<std::string>> diagnosticTroubleCode;

public:
    std::list<std::string>& getDiagnosticTroubleCode()
    {
        if (!diagnosticTroubleCode)
            diagnosticTroubleCode = std::make_unique<std::list<std::string>>();
        return *diagnosticTroubleCode;
    }
};

Note that the member getDiagnosticTroubleCode will return a reference to the new (or existing) instantiated list. If you decide to forego latent instantiation (I recommend doing so), the code becomes considerably simpler:

class DiagnosticTroubleCode 
{
protected:
    std::list<std::string> diagnosticTroubleCode;

public:
    std::list<std::string>& getDiagnosticTroubleCode()
    {
        return diagnosticTroubleCode;
    }
};

If the latter is possible (and frankly, I cannot see how it isn't), pursue that first. IN both cases above the member is returned by reference, not value or address. This would most-closely resemble what you're probably familiar with.

Best of luck.

Answer 2

I remember in Java everything are pointers. So in Java diagnosticTroubleCode == null is essentially comparing diagnosticTroubleCode with a null pointer. In C++ we do not have null, we have NULL or nullptr . In C++ an object cannot really be null because it is not. An object takes up a block of memory when it gets constructed, so it can never be null. So try to familiarize yourself with pointers and use that in your advantage.

On the matter of this . If you want to return a member variable, you don't really need to write return this.variable , you can simply return the variable by writing return variable .

Answer 3

The difference here is that in Java all complex structure declarations are really declarations of references to such structures. In C++, that's the equivalent of saying List& foo or List* foo . C/C++ declarations are true instances, which is one of the reasons why there can be a bit of complexity with memory management, but it comes with the benefit of information integrity: For example, when you pass a Java List<String> as an argument of a method and change the contents of that argument, it's changed in the calling scope. C/C++, on the other hand, will copy the argument regardless of object complexity, and when the function/method returns, the one passed as an argument is otherwise preserved.

Your C++ class example should look something like this:

#include <list>
#include <string>
using namespace std;

class RUNTIME_EXPORTS DiagnosticTroubleCode {
  protected:
    list<string>* diagnosticTroubleCode{nullptr};
  public:
    list<string>* getDiagnosticTroubleCode();
};

list<string>* DiagnosticTroubleCode::getDiagnosticTroubleCode(){
  if (diagnosticTroubleCode == nullptr) {
        diagnosticTroubleCode = new List<string>();
    }
    return diagnosticTroubleCode;
}

There are better implementations that don't require returning a pointer or reference, but they impose additional design requirements (such as what the adding a trouble-code mechanism should be).

Answer 4

You could use something like this

#include <iostream>
using namespace std;

Function

class DiagnosticTroubleCode 
{
protected:
    std::unique_ptr<std::list<std::string>> diagnosticTroubleCode;

public:
    std::list<std::string>& getDiagnosticTroubleCode()
    {
        if (!diagnosticTroubleCode)
            diagnosticTroubleCode = std::make_unique<std::list<std::string>>();
        return *diagnosticTroubleCode;
    }
};

Answer 5

My .cpp file :

shared_ptr<List> DiagnosticTroubleCodes::getDiagnosticTroubleCodes()
            {
                if (this->diagnosticTroubleCodes == nullptr) {
                    this->diagnosticTroubleCodes = make_shared<List>();
                }
                return diagnosticTroubleCodes;
            }

And My header file:

class RUNTIME_EXPORTS DiagnosticTroubleCodes {
            protected:
                shared_ptr<List> diagnosticTroubleCodes;
            public:
                shared_ptr<List> getDiagnosticTroubleCodes();
            };

I come up with this solution.