CODEWITHSUNDEEP
c++arraystemplatessmart-pointers
Flash_Steel
Flash_Steel

Reputation: 628

Std::Array with unique_ptr

I have an class which I wish to instantiate by passing an array of values. The object here has two members but this has been reduced for illustration. In the future I will read values from disk and then create an object from those values, hence the array. The object will have multiple pointers later on hence the shared_ptr.

Firstly, I would like to know if this would prevent memory leaks as is. Secondly, I would like to know if there is are less bloated ways of instantiating objects and then determinsitically destroying them later on.

Class Header file:

//MyClass.hpp
#pragma once
#include "stdafx.h"
#include <array>

class SimpleClass{
    private:
        //Per object
        double var1;
        double var2;
    public static:
        //For calling when using templates such as std::array<>
        //Using __int8 as will not be > 256
        static const uint8_t varCount 2;
        SimpleBody(std::array<double, varCount> inputArray);
        ~SimpleBody();
}

Class Implementation

//MyClass.cpp
#pragma once
#include "stdafx.h"
#include <array>
#include "body.hpp"

SimpleBody::SimpleBody(std::array<double, SimpleBody::varCount> inputArray ) {
    //Assign var1
    MyClass::var1= inputArray[0];
    //Assign var2
    MyClass::var2= inputArray[1];
};

SimpleBody::~SimpleBody() {
    //Add in code here when children need deleting
};

Entry Point

// EntryPoint.cpp
//

#include "stdafx.h"
#include "MyClass.hpp"
#include <array>
#include <memory>

int main()
{
    //Create an array with a smart pointer for memory management
    std::unique_ptr< std::array<double, MyClass::varCount> > initArray =
        std::make_unique< std::array<double, MyClass::varCount> >();
    //Define values
    *initArray = { 1.0,2.0 };
    //Use array to create object
    std::shared_ptr<MyClass> object = std::make_shared<MyClass>(*initArray );

    //Free memory
    initArray.reset();
    object.reset();

    return 0;
}

Upvotes: 1

Views: 2713

Answers (2)

Hayt
Hayt

Reputation: 5370

In your example you could skip the unique pointer because you only want the values anyway 

int main()
{
    std::array<double, MyClass::varCount> initArray = { 1.0,2.0 };
    std::shared_ptr<MyClass> object = std::make_shared<MyClass>(initArray );
    return 0;
}

This would do the same.

For "less bloated":

There is always auto: 

int main()
{
    auto initArray = std::make_unique< std::array<double,  MyClass::varCount> >();
    *initArray = {1.0,2.0};
    auto object = std::make_shared<MyClass>(*initArray );
    return 0;
}

Upvotes: 2

ladaManiak
ladaManiak

Reputation: 104

First of all its bad if you pass the array by value in the SimpleBody constructor. Better use a reference

 SimpleBody(const std::array<int, varCount> &inputArray);

At the moment, you construct your shared_ptr the unique_ptr looses the ownership of the array. You don't need to do reset manually. Also, at the moment, your program hits the } line, the memory will be freed.

Upvotes: 2

Related Questions