删除警告 C6001

Question

I am using VS2017 and do not understand why I am getting compiler "Warning C6001 Using uninitialized memory 'values'", on line if(values!= NULL) in catch block.

#include <windows.h>

typedef enum 
{        
   VALUE_STATE_NOT_AVAILABLE = 1,
   VALUE_STATE_ERROR         = 2,
   VALUE_STATE_VALID         = 3,
   VALUE_STATE_UNKNOWN       = 4
} XyzValueState_t;
    
class XyzValue
{
    private:    XyzValueState_t     _valueState;
    protected:  XyzValue( XyzValueState_t valueState )  {
                    _valueState = valueState;
                }
}

typedef XyzValue* xyzValuePtr_t;

main(){
    bool flag=true;
    xyzValuePtr_t* values = NULL;
    unsigned int _argument=2;
    if(flag==true)  {
        values = new PCLValuePtr_t[2]{ NULL,NULL }; 
        try     {
            values[0] = new PCLUnsignedInteger(_argument);
            values[1] = new PCLUnsignedInteger(_argument);
            xyz(values);    // passing the value to third party function which returns void
        }
        catch(...)  {
            if(values!= NULL){
                for(int k = 0; k < 1; k++)  {
                   delete values[k];
                   values[k] = NULL;      
                }
                delete [] values;
                values = NULL;
            }
        }
    }
}

Thank you in advance for your help and guidance

Answer 1

not quite sure why your compiler thinks this might be unitialized.

But, in C++, I'd argue that the way you're building your array with new is unnecessarily complicated and error prone. This look like someone from 1993 tried to write C++11. You have initializer lists, but you don't use RAII!

so, do the C++ thing and use C++'s deterministic object lifetime to manage memory. For an array of objects, this is elegantly handled by std::vector :

#include <vector>
class XyzValue;

main(){
    bool flag=true;
    unsigned int _argument=2;
    if(flag==true)  {
        std::vector<XyzValue> values(2);  // default initialization for two XyzValues.
        try     {
            xyz(values.data());    // if you need the raw contiguous memory. **You probably don't.**
        }
        catch(...)  {
// all the manual deletion not necessary anymore, because at end of scope, things are deconstructed automatically, so this catch clause now is empty.
        }
    }
}

See how this is much shorter, better readable, has the same functionality, but none of the need to manually delete anything? That's why we write C++ instead of C.