Initialisieren eines Arrays in einem Objekt in C ++

Question

Ich lerne gerade C ++ und habe eine kleine Array-Klasse erstellt.

Problem: Ich kann das Array im Objekt nicht mit dem Konstruktor initialisieren.

Was muss ich schreiben, um dieses Mitglied zu initialisieren? (Ich bin sicher, dass etwas mit der Syntax nicht stimmt.)

Code:

ary.h::

template<typename T_datatype>
class ary {

private:
    T_datatype* T_dataptr;

public:
    ary<T_datatype>(T_datatype* T_ptr) : T_dataptr(T_ptr) {}
};

main.cpp::

#include "ary.h"

int main()
{
    ary<int> array_int = {2, 3, 4}; //is it something like that?...

    return 0;
}

Answer 1

Der von Ihnen implementierte Konstruktor erwartet einen int*Zeiger als Eingabe, {2, 3, 4}zerfällt jedoch nicht in eine int*. Nein, die von Ihnen gezeigte Syntax funktioniert angesichts der Klasse, die Sie bisher implementiert haben, nicht.

Wenn Sie die genaue Arraygröße zur Kompilierungszeit kennen, können Sie dies std::arraystattdessen mit folgenden Methoden tun :

#include <array>

template<typename T, size_t N>
struct ary {
    std::array<T, N> data;
    ...
};

#include "ary.h"

int main()
{
    ary<int, 3> array_int1{2, 3, 4};

    ary<int, 3> array_int2 = {2, 3, 4};

    ary<int, 3> array_int3 = {{2, 3, 4}};

    return 0;
}

Wenn Sie andernfalls wirklich aryeinen Zeiger auf einige Array-Daten haben möchten , können Sie zuerst ein tatsächliches Array deklarieren und es dann an den Konstruktor übergeben, z.

template<typename T>
class ary {
private:
    T *dataptr;
    ...

public:
    ary(T* ptr) : dataptr(ptr) {}
    ...
};

#include "ary.h"

int main()
{
    int data[] = {2, 3, 4};
    ary<int> array_int(data);
    ...

    return 0;
};

Geben Sie Ihrer Klasse jedoch einen Konstruktor, der std::initializer_liststattdessen eine Eingabe als Eingabe verwendet, und lassen Sie die Klasse dann intern ein eigenes Array zuweisen (befolgen Sie nur die Regel vom 05.03.0 ), z.

#include <algorithm>
#include <utility>

template<typename T>
class ary {
private:
    T *dataptr = nullptr;
    int datasize = 0;

public:
    ary() = default;

    ary(const ary &src)
        : ary()
    {
        if (src.dataptr && src.datasize > 0)
        {
            dataptr = new T[size];
            datasize = src.datasize;
            std::copy(src.dataptr, src.dataptr+src.datasize, dataptr);
        }
    }

    ary(ary &&src)
        : dataptr(src.dataptr), datasize(src.datasize)
    {
        src.dataptr = nullptr;
        src.datasize = 0;
    }

    ary(T* ptr, int size)
        : dataptr(new T[size]), datasize(size)
    {
        std::copy(ptr, ptr+size, dataptr);
    }

    ary(std::initializer_list<T> l)
        : dataptr(new T[l.size()]), datasize(l.size())
    {
        std::copy(l.begin(), l.end(), dataptr);
    }

    ~ary()
    {
        delete[] dataptr;
    }

    ary& operator=(ary rhs)
    {
        std::swap(dataptr, rhs.dataptr);
        std::swap(datasize, rhs.datasize);
        return *this;
    }

    ...
};

#include "ary.h"

int main()
{
    ary<int> array_int1;

    ary<int> array_int2 = {2, 3, 4};

    int data[] = {2, 3, 4};
    ary<int> array_int3{data, 3};

    ary<int> array_int4{array_int2};

    ary<int> array_int5{std::move(array_int3)};

    ...

    return 0;
}

Eine bessere Option ist es, std::vectorstattdessen zu verwenden und die ganze Arbeit für Sie erledigen zu lassen, z.

#include <vector>

template<typename T>
class ary {
private:
    std::vector<T> data;

public:
    ary() = default;

    // the copy/move constructors, copy/move assignment operators,
    // and destructor will be implicitly generated for you...

    ary(T* ptr, int size) : data(ptr, size) {}
    ary(std::initializer_list<T> l) : data(l) {}

    ...
};

#include "ary.h"

int main()
{
    ary<int> array_int1;

    ary<int> array_int2 = {2, 3, 4};

    int data[] = {2, 3, 4};
    ary<int> array_int3{data, 3};

    ary<int> array_int4{array_int2};

    ary<int> array_int5{std::move(array_int3)};

    ...

    return 0;
}

Answer 2

Der Konstruktor:

ary<T_datatype> ... 

sollte einfach benannt werden:

ary ... 

dh ohne den Template-Parameter.

Die Hauptleitung:

ary<int> array_int = {2, 3, 4};

erwartet entweder einen Konstruktor, der drei ints erhält, oder einen Konstruktor, der std::initializer_list<int>keinen von beiden erhält , in Ihrer Klasse.

Answer 3

Leider erlaubt C ++ keine zusammengesetzten Literale - eine Funktion der C-Sprache, die hier nützlich sein könnte. Stattdessen müssen Sie Ihr Array-Argument dem Konstruktor als eigenständige Variable deklarieren und dieses dann an den Konstruktor übergeben:

int main()
{
//  ary<int> array_int = { 2, 3, 4 }; //is it something like that?...
    int data[] = { 2, 3, 4 };
    ary<int> array_int{ data }; // "data" will here decay into a pointer to its first element

    return 0;
}