Menginisialisasi array dalam sebuah objek di C ++
Saat ini saya belajar C ++ dan saya membuat kelas array kecil.
Masalah: Saya tidak dapat menginisialisasi array dalam objek dengan konstruktor.
Apa yang perlu saya tulis, untuk menginisialisasi anggota ini? (Saya yakin ada sesuatu dengan sintaksis yang salah.)
Kode:
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;
}
Jawaban
Konstruktor yang Anda implementasikan mengharapkan int*
pointer sebagai input, tetapi {2, 3, 4}
tidak meluruh menjadi int*
, jadi tidak, sintaks yang Anda tunjukkan tidak akan berfungsi mengingat kelas yang telah Anda implementasikan sejauh ini.
Jika Anda mengetahui ukuran larik yang tepat pada waktu kompilasi, Anda dapat melakukannya dengan menggunakan std::array:
#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;
}
Jika tidak, jika Anda benar-benar ingin ary
memiliki pointer ke beberapa data array, Anda dapat mendeklarasikan array aktual terlebih dahulu, lalu meneruskannya ke konstruktor, misalnya:
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;
};
Tetapi pertimbangkan untuk memberi kelas Anda konstruktor yang mengambil a std::initializer_listsebagai masukan, dan kemudian minta kelas mengalokasikan arraynya sendiri secara internal (pastikan untuk mengikuti Aturan 3/5/0 ), misalnya:
#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;
}
Pilihan yang lebih baik adalah menggunakan std::vectorsebagai gantinya, dan biarkan itu melakukan semua pekerjaan untuk Anda, misalnya:
#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;
}
Konstruktor:
ary<T_datatype> ...
harus diberi nama sederhana:
ary ...
yaitu tanpa parameter template.
Garis utama:
ary<int> array_int = {2, 3, 4};
mengharapkan konstruktor yang mendapatkan tiga int
s atau konstruktor yang std::initializer_list<int>
tidak mendapatkan satupun dari mereka di kelas Anda.
Sayangnya, C ++ tidak mengizinkan literal majemuk - fitur bahasa C yang dapat berguna di sini. Sebagai gantinya, Anda perlu mendeklarasikan 'argumen' array Anda ke konstruktor sebagai variabel dalam dirinya sendiri, lalu meneruskannya ke konstruktor:
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;
}