Inicjowanie nawiasów klamrowych
Nie zawsze jest konieczne zdefiniowanie konstruktora dla class
elementu , zwłaszcza tych, które są stosunkowo proste. Użytkownicy mogą inicjować obiekty obiektu class
lub struct
przy użyciu ujednoliconej inicjalizacji, jak pokazano w poniższym przykładzie:
// no_constructor.cpp
// Compile with: cl /EHsc no_constructor.cpp
#include <time.h>
// No constructor
struct TempData
{
int StationId;
time_t timeSet;
double current;
double maxTemp;
double minTemp;
};
// Has a constructor
struct TempData2
{
TempData2(double minimum, double maximum, double cur, int id, time_t t) :
stationId{id}, timeSet{t}, current{cur}, maxTemp{maximum}, minTemp{minimum} {}
int stationId;
time_t timeSet;
double current;
double maxTemp;
double minTemp;
};
int main()
{
time_t time_to_set;
// Member initialization (in order of declaration):
TempData td{ 45978, time(&time_to_set), 28.9, 37.0, 16.7 };
// When there's no constructor, an empty brace initializer does
// value initialization = {0,0,0,0,0}
TempData td_emptyInit{};
// Uninitialized = if used, emits warning C4700 uninitialized local variable
TempData td_noInit;
// Member declaration (in order of ctor parameters)
TempData2 td2{ 16.7, 37.0, 28.9, 45978, time(&time_to_set) };
return 0;
}
Jeśli konstruktor lub struct
nie ma konstruktoraclass
, należy podać elementy listy w kolejności, w której składowe są zadeklarowane w obiekcie class
. Jeśli element class
ma konstruktor, podaj elementy w kolejności parametrów. Jeśli typ ma konstruktor domyślny, niejawnie lub jawnie zadeklarowany, można użyć inicjowania nawiasów klamrowych z pustymi nawiasami klamrowymi, aby go wywołać. Na przykład można zainicjować następujące class
elementy przy użyciu inicjowania pustego i niepustego nawiasu klamrowego:
#include <string>
using namespace std;
class class_a {
public:
class_a() {}
class_a(string str) : m_string{ str } {}
class_a(string str, double dbl) : m_string{ str }, m_double{ dbl } {}
double m_double;
string m_string;
};
int main()
{
class_a c1{};
class_a c1_1;
class_a c2{ "ww" };
class_a c2_1("xx");
// order of parameters is the same as the constructor
class_a c3{ "yy", 4.4 };
class_a c3_1("zz", 5.5);
}
Jeśli klasa ma konstruktory inne niż domyślne, kolejność, w której składowe klasy pojawiają się w inicjatorze nawiasu klamrowego, jest kolejność, w której odpowiednie parametry pojawiają się w konstruktorze, a nie kolejność, w której składowe są deklarowane (jak class_a
w poprzednim przykładzie). W przeciwnym razie, jeśli typ nie ma zadeklarowanego konstruktora, inicjatory składowych muszą pojawić się w inicjatorze nawiasu klamrowego w takiej samej kolejności, jak zadeklarowano. W takim przypadku można zainicjować dowolną liczbę członków publicznych, ale nie można pominąć żadnego członka. W poniższym przykładzie pokazano kolejność używaną w inicjowaniu nawiasu klamrowego, gdy nie ma zadeklarowanej konstruktora:
class class_d {
public:
float m_float;
string m_string;
wchar_t m_char;
};
int main()
{
class_d d1{};
class_d d1{ 4.5 };
class_d d2{ 4.5, "string" };
class_d d3{ 4.5, "string", 'c' };
class_d d4{ "string", 'c' }; // compiler error
class_d d5{ "string", 'c', 2.0 }; // compiler error
}
Jeśli domyślny konstruktor jest jawnie zadeklarowany, ale oznaczony jako usunięty, nie można użyć pustego inicjowania nawiasu klamrowego:
class class_f {
public:
class_f() = delete;
class_f(string x): m_string { x } {}
string m_string;
};
int main()
{
class_f cf{ "hello" };
class_f cf1{}; // compiler error C2280: attempting to reference a deleted function
}
Inicjalizacji nawiasu klamrowego można używać w dowolnym miejscu, w którym zwykle wykonuje się inicjowanie — na przykład jako parametr funkcji lub wartość zwracaną albo za pomocą słowa kluczowego new
:
class_d* cf = new class_d{4.5};
kr->add_d({ 4.5 });
return { 4.5 };
W /std:c++17
trybie i nowszych reguły inicjowania pustego nawiasu klamrowego są nieco bardziej restrykcyjne. Zobacz Konstruktory pochodne i rozszerzoną inicjację agregacji.
konstruktory initializer_list
Klasa initializer_list reprezentuje listę obiektów określonego typu, które mogą być używane w konstruktorze i w innych kontekstach. Można utworzyć initializer_list przy użyciu inicjowania nawiasu klamrowego:
initializer_list<int> int_list{5, 6, 7};
Ważne
Aby użyć tej klasy, należy dołączyć nagłówek initializer_list>.<
Można skopiować obiekt initializer_list
. W takim przypadku członkowie nowej listy są odwołaniami do członków oryginalnej listy:
initializer_list<int> ilist1{ 5, 6, 7 };
initializer_list<int> ilist2( ilist1 );
if (ilist1.begin() == ilist2.begin())
cout << "yes" << endl; // expect "yes"
Standardowe klasy kontenerów biblioteki, a także string
, wstring
i regex
, mają initializer_list
konstruktory. W poniższych przykładach pokazano, jak wykonać inicjowanie nawiasów klamrowych przy użyciu tych konstruktorów:
vector<int> v1{ 9, 10, 11 };
map<int, string> m1{ {1, "a"}, {2, "b"} };
string s{ 'a', 'b', 'c' };
regex rgx{ 'x', 'y', 'z' };
Zobacz też
Opinia
https://aka.ms/ContentUserFeedback.
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź:Prześlij i wyświetl opinię dla