C++ What syntax for avoid duplicated declarations?

Question

I'm learning C++ and especially OO Programming.

My program use pointers to deal with Dynamic memory allocation.

While creating my default constructor, I was boring about repeat myself with

myInt = new int;
myOtherInt = new int; 

etc..

So my question is : is there a way to write something like :

myInt, myOtherInt = new int;

Here's my constructor code :

Annonce::Annonce(string Titre, long double Prix, string Intro, string Description, vector<vector<string>> ImgUrls) {

    titre = new string;
    intro = new string;
    description = new string;
    imgUrls = new vector<vector<string>>;
    prix = new long double;

    id = new size_t;
    *id = nbAnnonces;

    *titre = std::move(Titre);
    *prix = Prix;
    *intro = std::move(Intro);
    *description = std::move(Description);
    *imgUrls = std::move(ImgUrls);

}

Answer 1

There is no shortcut for allocating multiple variables from dynamic memory.

The functions for allocating memory return a single memory address (pointer). Each variable should have its own, unique, location in memory.

The syntax of the C++ language would need to change in order to support the dynamic memory functions returning multiple addresses (pointers).

One recommendation is to reduce the quantity of memory allocations. Ask yourself, "Do I really need to allocate from dynamic memory?" before allocating from dynamic memory.

Answer 2

Is there a way to write something like :

myInt, myOtherInt = new int;

Yes, two ways. But the first is more general than what you specifically asked for...

1. Prefer value-types over reference-types

If you don't know what these are: Value types and Reference Types (Wikipedia).

In some programming languages, almost all of your variables, function parameters, class fields, etc - are references. A prominent example of this is Java. But in C++ - especially these days - we prefer values to references unless there's a good reason not to use values directly. Value semantics are commonly used and well-supported in the language, and most work with them is easier. See also:

Why are pointers not recommended when coding with C++11

Specifically, that means that, when defining a struct or a class, we'll give it non-pointer members. In your case:

class Announcement {
public:
    using url_type = std::string; // perhaps use a URL library?
    using image_urls_container_type = std::unoredered_set<url_type>;
        // I'm guessing the URLs aren't really ordered

    std::string title;
    std::string introduction;
    std::string description;
    std::vector<image_urls_container_type> image_urls;
        // Are the images really a sequence of indices? Shouldn't this be something like
        // std::unordered_map<image_id_type,image_urls_container_type> image_urls ?
    long double prize;
    std::size_t id;

    Announcement() = delete;
    // constructors here, if you like
}

Now, I'm not saying this is necessarily the best possible definition or that it fits all your needs. But if you define it this way, you get:

• No need to use new, ever.
• No need to delete anything.
• No chance of memory leaks (due to this class)

2. Otherwise, use std::unique_ptr's

The std::unique_ptr<T> class lets you avoid having to manage memory yourself - it takes care of that. So if you make your members std::unique_ptr's, you can initialize the value they point to using get(), e.g.:

void foo(int x) {
    auto p = std::make_unique<p>();
    p.get() = x;
    // do stuff with p

    // ...

    // no need to delete p at the end of the function
}

Answer 3

First Pre Answer Suggestion: don't do it.

Second Pre Answer Suggestion: avoid self-managed memory allocation/deallocation and use STL containers and/or smart pointers (std::unique_ptr, std::shared_ptr, etc.) instead

Answer: no, as far I know you can't write something as

int * myInt, myOtherInt = new int;

that allocate both variables (with different allocated pointers).

But you can wrap the pointers in a class or struct that automatically allocate the contained pointer (and, maybe, destroy it in the destructor).

Just for fun... if you write a wrapper as follows

template <typename T>
struct wrappPnt
 {
   T * pnt = new T{};

   T & operator * ()
    { return *pnt; }

   T const & operator * () const
    { return *pnt; }

   ~wrappPnt ()
    { delete pnt; }
 };

you can write your Annonce this way

struct Annonce
 {
   wrappPnt<std::string>  titre, intro, description;
   wrappPnt<std::vector<std::vector<std::string>>> imgUrls;
   wrappPnt<long double>  prix;


   Annonce (std::string Titre, long double Prix, std::string Intro,
            std::string Description,
            std::vector<std::vector<std::string>> ImgUrls)
    {
      *titre = std::move(Titre);
      *prix = Prix;
      *intro = std::move(Intro);
      *description = std::move(Description);
      *imgUrls = std::move(ImgUrls);
    }
 };

First Post Answer Suggestion: don't do it.

Second Post Answer Suggestion: avoid self-managed memory allocation/deallocation and use STL containers and/or smart pointers (std::unique_ptr, std::shared_ptr, etc.) instead