Auf dieser Seite

QLocale Class

Die Klasse „QLocale“ wandelt Zahlen in ihre Zeichenfolgendarstellungen in verschiedenen Sprachen um und umgekehrt. Mehr...

Header: #include <QLocale>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Hinweis: Alle Funktionen dieser Klasse sind reentrant, mit folgenden Ausnahmen:

QLocale-Vergleiche

KategorieVergleichbare Typen
GleichheitQLocale

Öffentliche Typen

enum Country { AnyCountry, AnyTerritory, Afghanistan, AlandIslands, Albania, …, Zimbabwe }
enum CurrencySymbolFormat { CurrencyIsoCode, CurrencySymbol, CurrencyDisplayName }
enum DataSizeFormat { DataSizeIecFormat, DataSizeTraditionalFormat, DataSizeSIFormat }
flags DataSizeFormats
enum FloatingPointPrecisionOption { FloatingPointShortest }
enum FormatType { LongFormat, ShortFormat, NarrowFormat }
enum Language { AnyLanguage, C, Abkhazian, Afan, Afar, …, Zulu }
enum LanguageCodeType { ISO639Part1, ISO639Part2B, ISO639Part2T, ISO639Part3, LegacyLanguageCode, …, AnyLanguageCode }
flags LanguageCodeTypes
enum MeasurementSystem { MetricSystem, ImperialUSSystem, ImperialUKSystem, ImperialSystem }
enum NumberOption { DefaultNumberOptions, OmitGroupSeparator, RejectGroupSeparator, OmitLeadingZeroInExponent, RejectLeadingZeroInExponent, …, RejectTrailingZeroesAfterDot }
flags NumberOptions
enum QuotationStyle { StandardQuotation, AlternateQuotation }
enum Script { AnyScript, AdlamScript, AhomScript, AnatolianHieroglyphsScript, ArabicScript, …, YiScript }
(since 6.7) enum class TagSeparator { Dash, Underscore }
Territory

Öffentliche Funktionen

QLocale()
(since 6.3) QLocale(QStringView name)
QLocale(QLocale::Language Sprache, QLocale::Territory Gebiet)
QLocale(QLocale::Language Sprache, QLocale::Script Schrift = AnyScript, QLocale::Territory Gebiet = AnyTerritory)
QLocale(const QString&name)
QLocale(const QLocale&other)
~QLocale()
QString amText() const
QString bcp47Name(QLocale::TagSeparator separator = TagSeparator::Dash) const
QLocale collation() const
QString createSeparatedList(const QStringList&list) const
QString currencySymbol(QLocale::CurrencySymbolFormat format = CurrencySymbol) const
QString dateFormat(QLocale::FormatType format = LongFormat) const
QString dateTimeFormat(QLocale::FormatType format = LongFormat) const
QString dayName(int day, QLocale::FormatType type = LongFormat) const
QString decimalPoint() const
QString exponential() const
Qt::DayOfWeek firstDayOfWeek() const
QString formattedDataSize(qint64 Bytes, int precision = 2, QLocale::DataSizeFormats format = DataSizeIecFormat) const
QString groupSeparator() const
QLocale::Language language() const
QLocale::MeasurementSystem measurementSystem() const
QString monthName(int month, QLocale::FormatType type = LongFormat) const
QString name(QLocale::TagSeparator separator = TagSeparator::Underscore) const
QString nativeLanguageName() const
(since 6.2) QString nativeTerritoryName() const
QString negativeSign() const
QLocale::NumberOptions numberOptions() const
QString percent() const
QString pmText() const
QString positiveSign() const
QString quoteString(const QString&str, QLocale::QuotationStyle style = StandardQuotation) const
(since 6.0) QString quoteString(QStringView str, QLocale::QuotationStyle style = StandardQuotation) const
QLocale::Script script() const
void setNumberOptions(QLocale::NumberOptions options)
QString standaloneDayName(int day, QLocale::FormatType type = LongFormat) const
QString standaloneMonthName(int month, QLocale::FormatType type = LongFormat) const
void swap(QLocale&other)
(since 6.2) QLocale::Territory territory() const
Qt::LayoutDirection textDirection() const
QString timeFormat(QLocale::FormatType format = LongFormat) const
QString toCurrencyString(qlonglong value, const QString&symbol = QString()) const
QString toCurrencyString(int value, const QString&symbol = QString()) const
QString toCurrencyString(qulonglong Wert, const QString&Symbol = QString()) const
QString toCurrencyString(short value, const QString&symbol = QString()) const
QString toCurrencyString(uint Wert, const QString&Symbol = QString()) const
QString toCurrencyString(ushort value, const QString&symbol = QString()) const
QString toCurrencyString(double value, const QString&symbol = QString(), int precision = -1) const
QString toCurrencyString(float i, const QString&symbol = QString(), int precision = -1) const
QDate toDate(const QString&string, QLocale::FormatType format = LongFormat, int baseYear = DefaultTwoDigitBaseYear) const
QDate toDate(const QString&string, const QString&format, int baseYear = DefaultTwoDigitBaseYear) const
QDate toDate(const QString&string, QLocale::FormatType format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const
QDate toDate(const QString&string, const QString&format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const
QDateTime toDateTime(const QString&string, QLocale::FormatType format = LongFormat, int baseYear = DefaultTwoDigitBaseYear) const
QDateTime toDateTime(const QString&string, const QString&format, int baseYear = DefaultTwoDigitBaseYear) const
QDateTime toDateTime(const QString&string, QLocale::FormatType format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const
QDateTime toDateTime(const QString&string, const QString&format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const
double toDouble(QStringView s, bool*ok = nullptr) const
double toDouble(const QString&s, bool*ok = nullptr) const
float toFloat(QStringView s, bool*ok = nullptr) const
float toFloat(const QString&s, bool*ok = nullptr) const
int toInt(QStringView s, bool*ok = nullptr) const
int toInt(const QString&s, bool*ok = nullptr) const
long toLong(QStringView s, bool*ok = nullptr) const
long toLong(const QString&s, bool*ok = nullptr) const
qlonglong toLongLong(QStringView s, bool*ok = nullptr) const
qlonglong toLongLong(const QString&s, bool*ok = nullptr) const
QString toLower(const QString&str) const
short toShort(QStringView s, bool*ok = nullptr) const
short toShort(const QString&s, bool*ok = nullptr) const
QString toString(qlonglong i) const
QString toString(QTime time, QLocale::FormatType format = LongFormat) const
QString toString(QDate date, QLocale::FormatType format, QCalendar cal) const
QString toString(const QDateTime&dateTime, QLocale::FormatType format, QCalendar cal) const
QString toString(const QDateTime&dateTime, QStringView format, QCalendar cal) const
QString toString(int i) const
QString toString(long i) const
QString toString(qulonglong i) const
QString toString(short i) const
QString toString(uint i) const
QString toString(ulong i) const
QString toString(ushort i) const
QString toString(QDate date, QLocale::FormatType format = LongFormat) const
QString toString(QDate date, QStringView format) const
QString toString(QDate date, const QString&format) const
QString toString(QTime time, QStringView format) const
QString toString(QTime time, const QString&format) const
QString toString(const QDateTime&dateTime, QLocale::FormatType format = LongFormat) const
QString toString(const QDateTime&dateTime, QStringView format) const
QString toString(const QDateTime&dateTime, const QString&format) const
QString toString(QDate date, QStringView format, QCalendar cal) const
QString toString(double f, char format = 'g', int precision = 6) const
QString toString(float f, char format = 'g', int precision = 6) const
QString toString(int number, int fieldWidth, char32_t fillChar) const
QString toString(long number, int fieldWidth, char32_t fillChar) const
QString toString(qlonglong number, int fieldWidth, char32_t fillChar) const
QString toString(qulonglong number, int fieldWidth, char32_t fillChar) const
QString toString(short number, int fieldWidth, char32_t fillChar) const
QString toString(uint number, int fieldWidth, char32_t fillChar) const
QString toString(ulong number, int fieldWidth, char32_t fillChar) const
QString toString(ushort number, int fieldWidth, char32_t fillChar) const
QTime toTime(const QString&string, QLocale::FormatType format = LongFormat) const
QTime toTime(const QString&string, const QString&format) const
uint toUInt(QStringView s, bool*ok = nullptr) const
uint toUInt(const QString&s, bool*ok = nullptr) const
ulong toULong(QStringView s, bool*ok = nullptr) const
ulong toULong(const QString&s, bool*ok = nullptr) const
qulonglong toULongLong(QStringView s, bool*ok = nullptr) const
qulonglong toULongLong(const QString&s, bool*ok = nullptr) const
ushort toUShort(QStringView s, bool*ok = nullptr) const
ushort toUShort(const QString&s, bool*ok = nullptr) const
QString toUpper(const QString&str) const
QStringList uiLanguages(QLocale::TagSeparator separator = TagSeparator::Dash) const
QList<Qt::DayOfWeek> weekdays() const
QString zeroDigit() const
QLocale &operator=(const QLocale&other)

Statische öffentliche Mitglieder

(since 6.7) const int DefaultTwoDigitBaseYear
QLocale c()
(since 6.3) QLocale::Language codeToLanguage(QStringView languageCode, QLocale::LanguageCodeTypes codeTypes = AnyLanguageCode)
(since 6.1) QLocale::Script codeToScript(QStringView scriptCode)
(since 6.2) QLocale::Territory codeToTerritory(QStringView territoryCode)
(since 6.3) QString languageToCode(QLocale::Language language, QLocale::LanguageCodeTypes codeTypes = AnyLanguageCode)
QString languageToString(QLocale::Language language)
QList<QLocale> matchingLocales(QLocale::Language language, QLocale::Script script, QLocale::Territory territory)
(since 6.1) QString scriptToCode(QLocale::Script script)
QString scriptToString(QLocale::Script script)
void setDefault(const QLocale &locale)
QLocale system()
(since 6.2) QString territoryToCode(QLocale::Territory territory)
(since 6.2) QString territoryToString(QLocale::Territory territory)
size_t qHash(const QLocale &key, size_t seed = 0)
bool operator!=(const QLocale &lhs, const QLocale &rhs)
bool operator==(const QLocale &lhs, const QLocale &rhs)

Ausführliche Beschreibung

QLocale wird für eine bestimmte Sprache, ein optionales Schriftsystem und eine Region instanziiert. Es bietet verschiedene Funktionen zur Formatierung von Daten als Text, der entsprechend lokalisiert ist, sowie zum Auslesen von Daten aus lokalisiertem Text.

Beispiel:

QLocale egyptian(QLocale::Arabic, QLocale::Egypt);
QString s1 = egyptian.toString(1.571429E+07, 'e');
QString s2 = egyptian.toString(10);

double d = egyptian.toDouble(s1);
int i = egyptian.toInt(s2);

QLocale unterstützt das Konzept einer Standard-Locale, die beim Start der Anwendung anhand der Locale-Einstellungen des Systems ermittelt wird. Die Standard-Locale kann durch Aufruf des statischen Mitglieds ` setDefault()` geändert werden. Die Festlegung der Standard-Locale hat folgende Auswirkungen:

  • Wird ein QLocale-Objekt mit dem Standardkonstruktor instanziiert, verwendet es die Einstellungen der Standard-Locale.
  • QString::arg() verwendet die Standard-Locale zur Formatierung einer Zahl, wenn deren Positionsbezeichner in der Formatzeichenfolge ein „L“ enthält, z. B. „%L1“.

Das folgende Beispiel veranschaulicht die direkte Verwendung von QLocale:

bool ok;
double d;

QLocale::setDefault(QLocale::C);      // uses '.' as a decimal point
QLocale cLocale;                      // default-constructed C locale
d = cLocale.toDouble("1234,56", &ok); // ok == false, d == 0
d = cLocale.toDouble("1234.56", &ok); // ok == true,  d == 1234.56

QLocale::setDefault(QLocale::German); // uses ',' as a decimal point
QLocale german;                       // default-constructed German locale
d = german.toDouble("1234,56", &ok);  // ok == true,  d == 1234.56
d = german.toDouble("1234.56", &ok);  // ok == false, d == 0

QLocale::setDefault(QLocale::English);
// Default locale now uses ',' as a group separator.
QString str = QString("%1 %L2 %L3").arg(12345).arg(12345).arg(12345, 0, 16);
// str == "12345 12,345 3039"

Eine alternative Methode zum Erstellen eines QLocale-Objekts besteht darin, den Namen der Locale anzugeben.

QLocale korean("ko");
QLocale swiss("de_CH");

Dieser Konstruktor liest die Sprache, das Schriftsystem und/oder das Gebiet aus dem angegebenen Namen aus und akzeptiert dabei entweder einen Unterstrich oder einen Bindestrich als Trennzeichen (wobei etwaige nachgestellte Suffixe wie „ .codeset “ oder „ @variant “ ignoriert werden).

Hinweis: Informationenzur aktuellen Tastatureingabe-Locale finden Sie unter QInputMethod::locale().

Eignung der Formate

Die Daten von QLocale basieren auf dem Common Locale Data Repository v48.2.

Diese Daten werden vom Unicode-Konsortium veröffentlicht, das bestrebt ist, den üblichen, gängigen Gepflogenheiten der Schreiber jeder Sprache, in jeder Schrift und in jedem Gebiet, für das Daten vorliegen, zu folgen. Dies kann in einigen Fällen von dem abweichen, was als offiziell anerkannt ist, je nachdem, wie weit verbreitet die Befolgung dieses offiziellen Standards in der Praxis ist.

Obwohl beispielsweise der einschlägige internationale Standard (des BIPM) ein schmales, nicht trennbares Leerzeichen als Trennzeichen zwischen Zifferngruppen in Zahlen vorschreibt, wenn diese zur besseren Lesbarkeit aufgeteilt werden, und viele Länder dies als offiziellen Standard für die Formatierung von Zahlen übernommen haben, verwenden viele Regionen in der Praxis jedoch eine traditionelle Art der Zahlenformatierung, bei der Zifferngruppen durch Satzzeichen getrennt werden. CLDR und damit auch QLocale folgen diesem gängigen Sprachgebrauch und nicht dem offiziellen Standard.

Übereinstimmende Kombinationen aus Sprache, Schrift und Gebiet

QLocale verfügt über Daten, die aus CLDR abgeleitet sind, für viele Kombinationen aus Sprache, Schrift und Gebiet, jedoch nicht für alle. Wenn es mit allen drei dieser Schlüsselwerte angegeben wird (wobei AnyLanguage, AnyScript oder AnyTerritory als nicht angegeben behandelt werden) und QLocale über Daten für die angegebene Kombination verfügt, werden diese Daten verwendet. Andernfalls versucht QLocale nach Kräften, eine sinnvolle Kombination aus Sprache, Schrift und Gebiet zu finden, für die Daten vorliegen und die mit den angegebenen Werten übereinstimmt.

Das CLDR stellt Tabellen mit wahrscheinlichen Kombinationen bereit, die zum Ausfüllen nicht angegebener Schlüssel verwendet werden; wenn QLocale Daten für das Ergebnis einer solchen wahrscheinlichen Kombination hat, werden diese verwendet. Wenn keine Sprache angegeben ist und sich auch keine aus Schrift und Gebiet ableiten lässt oder wenn QLocale keine Daten für die Sprache hat, wird die „C“-Locale (beim Einlesen der Schlüssel aus einer Zeichenkette) oder die Standard-Locale (ansonsten) verwendet.

Wenn QLocale keine Daten für die angegebenen Schlüssel hat – wobei wahrscheinliche Schlüssel anstelle der nicht angegebenen eingesetzt werden –, aber Daten für die resultierende Sprache besitzt, wird ein Fallback gesucht, indem entweder das Gebiet, die Schrift oder beides (in dieser Reihenfolge) ignoriert wird. Dies führt zu einer QLocale, die möglicherweise nicht der Anfrage entspricht, aber für die angegebenen Schlüssel eine Lokalisierung bereitstellt, die so gut ist, wie es die verfügbaren Daten zulassen.

Verwenden Sie ` language()`, ` script()` und ` territory()`, um die tatsächlich verwendeten Schlüssel zu ermitteln.

Siehe auch ` QString::arg()` und ` QInputMethod::locale()`.

Dokumentation zu Mitgliedstypen

enum QLocale::Country

Dieser Aufzählungstyp dient zur Identifizierung eines Gebiets.

Ein einzelnes Gebiet kann eine Provinz eines Landes, ein Land (der mit Abstand häufigste Fall) oder eine größere geografische Einheit sein, auf die sich bestimmte Lokalisierungsdetails beziehen.

KonstanteWertBeschreibung
QLocale::AnyCountryAnyTerritoryVeralteter Alias für AnyTerritory
QLocale::AnyTerritory (since Qt 6.2)0 
QLocale::Afghanistan1 
QLocale::AlandIslands2 
QLocale::Albania3 
QLocale::Algeria4 
QLocale::AmericanSamoa5 
QLocale::Andorra6 
QLocale::Angola7 
QLocale::Anguilla8 
QLocale::Antarctica9 
QLocale::AntiguaAndBarbuda10 
QLocale::Argentina11 
QLocale::Armenia12 
QLocale::Aruba13 
QLocale::AscensionIsland14 
QLocale::Australia15 
QLocale::Austria16 
QLocale::Azerbaijan17 
QLocale::Bahamas18 
QLocale::Bahrain19 
QLocale::Bangladesh20 
QLocale::Barbados21 
QLocale::Belarus22 
QLocale::Belgium23 
QLocale::Belize24 
QLocale::Benin25 
QLocale::Bermuda26 
QLocale::Bhutan27 
QLocale::Bolivia28 
QLocale::BonaireCaribbeanNetherlands 
QLocale::BosniaAndHerzegowinaBosniaAndHerzegovinaVeraltet, bitte stattdessen „ BosniaAndHerzegovina “ verwenden
QLocale::BosniaAndHerzegovina (since Qt 6.0)29 
QLocale::Botswana30 
QLocale::BouvetIsland31 
QLocale::Brazil32 
QLocale::BritishIndianOceanTerritory33 
QLocale::BritishVirginIslands34 
QLocale::Brunei35 
QLocale::Bulgaria36 
QLocale::BurkinaFaso37 
QLocale::Burundi38 
QLocale::Cambodia39 
QLocale::Cameroon40 
QLocale::Canada41 
QLocale::CanaryIslands42 
QLocale::CaribbeanNetherlands44 
QLocale::CapeVerde43 
QLocale::CaymanIslands45 
QLocale::CentralAfricanRepublic46 
QLocale::CeutaAndMelilla47 
QLocale::Chad48 
QLocale::Chile49 
QLocale::China50 
QLocale::ChristmasIsland51 
QLocale::ClippertonIsland52 
QLocale::CocosIslands53 
QLocale::Colombia54 
QLocale::Comoros55 
QLocale::CongoBrazzaville56 
QLocale::CongoKinshasa57 
QLocale::CookIslands58 
QLocale::CostaRica59 
QLocale::Croatia60 
QLocale::Cuba61 
QLocale::Curacao (since Qt 6.0)62 
QLocale::CuraSaoCuracaoVeraltet, bitte stattdessen „ Curacao “ verwenden
QLocale::Cyprus63 
QLocale::Czechia (since Qt 6.0)64 
QLocale::CzechRepublicCzechiaVeraltet, bitte stattdessen Czechia verwenden
QLocale::DemocraticRepublicOfCongoCongoKinshasaVeraltet, bitte stattdessen CongoKinshasa verwenden
QLocale::DemocraticRepublicOfKoreaNorthKoreaVeraltet, bitte stattdessen NorthKorea verwenden
QLocale::Denmark65 
QLocale::DiegoGarcia66 
QLocale::Djibouti67 
QLocale::Dominica68 
QLocale::DominicanRepublic69 
QLocale::EastTimorTimorLeste 
QLocale::Ecuador70 
QLocale::Egypt71 
QLocale::ElSalvador72 
QLocale::EquatorialGuinea73 
QLocale::Eritrea74 
QLocale::Estonia75 
QLocale::Eswatini76 
QLocale::Ethiopia77 
QLocale::EuropeanUnion (since Qt 5.7)79 
QLocale::Europe (since Qt 5.12)78 
QLocale::FalklandIslands80 
QLocale::FaroeIslands81 
QLocale::Fiji82 
QLocale::Finland83 
QLocale::France84 
QLocale::FrenchGuiana85 
QLocale::FrenchPolynesia86 
QLocale::FrenchSouthernTerritories87 
QLocale::Gabon88 
QLocale::Gambia89 
QLocale::Georgia90 
QLocale::Germany91 
QLocale::Ghana92 
QLocale::Gibraltar93 
QLocale::Greece94 
QLocale::Greenland95 
QLocale::Grenada96 
QLocale::Guadeloupe97 
QLocale::Guam98 
QLocale::Guatemala99 
QLocale::Guernsey100 
QLocale::Guinea102 
QLocale::GuineaBissau101 
QLocale::Guyana103 
QLocale::Haiti104 
QLocale::HeardAndMcDonaldIslands105 
QLocale::Honduras106 
QLocale::HongKong107 
QLocale::Hungary108 
QLocale::Iceland109 
QLocale::India110 
QLocale::Indonesia111 
QLocale::Iran112 
QLocale::Iraq113 
QLocale::Ireland114 
QLocale::IsleOfMan115 
QLocale::Israel116 
QLocale::Italy117 
QLocale::IvoryCoast118 
QLocale::Jamaica119 
QLocale::Japan120 
QLocale::Jersey121 
QLocale::Jordan122 
QLocale::Kazakhstan123 
QLocale::Kenya124 
QLocale::Kiribati125 
QLocale::Kosovo (since Qt 5.2)126 
QLocale::Kuwait127 
QLocale::Kyrgyzstan128 
QLocale::Laos129 
QLocale::LatinAmerica130 
QLocale::LatinAmericaAndTheCaribbeanLatinAmericaVeraltet, bitte stattdessen „ LatinAmerica “ verwenden
QLocale::Latvia131 
QLocale::Lebanon132 
QLocale::Lesotho133 
QLocale::Liberia134 
QLocale::Libya135 
QLocale::Liechtenstein136 
QLocale::Lithuania137 
QLocale::Luxembourg138 
QLocale::Macao139 
QLocale::MacauMacao 
QLocale::Macedonia140 
QLocale::Madagascar141 
QLocale::Malawi142 
QLocale::Malaysia143 
QLocale::Maldives144 
QLocale::Mali145 
QLocale::Malta146 
QLocale::MarshallIslands147 
QLocale::Martinique148 
QLocale::Mauritania149 
QLocale::Mauritius150 
QLocale::Mayotte151 
QLocale::Mexico152 
QLocale::Micronesia153 
QLocale::Moldova154 
QLocale::Monaco155 
QLocale::Mongolia156 
QLocale::Montenegro157 
QLocale::Montserrat158 
QLocale::Morocco159 
QLocale::Mozambique160 
QLocale::Myanmar161 
QLocale::Namibia162 
QLocale::NauruCountryNauruTerritoryVeralteter Alias für NauruTerritory
QLocale::NauruTerritory (since Qt 6.2)163 
QLocale::Nepal164 
QLocale::Netherlands165 
QLocale::NewCaledonia166 
QLocale::NewZealand167 
QLocale::Nicaragua168 
QLocale::Niger170 
QLocale::Nigeria169 
QLocale::Niue171 
QLocale::NorfolkIsland172 
QLocale::NorthernMarianaIslands173 
QLocale::NorthKorea174 
QLocale::Norway175 
QLocale::Oman176 
QLocale::OutlyingOceania (since Qt 5.7)177 
QLocale::Pakistan178 
QLocale::Palau179 
QLocale::PalestinianTerritories180 
QLocale::Panama181 
QLocale::PapuaNewGuinea182 
QLocale::Paraguay183 
QLocale::PeoplesRepublicOfCongoCongoBrazzavilleVeraltet, bitte stattdessen „ CongoBrazzaville “ verwenden
QLocale::Peru184 
QLocale::Philippines185 
QLocale::Pitcairn186 
QLocale::Poland187 
QLocale::Portugal188 
QLocale::PuertoRico189 
QLocale::Qatar190 
QLocale::RepublicOfKoreaSouthKoreaVeraltet, bitte stattdessen „ SouthKorea “ verwenden
QLocale::Reunion191 
QLocale::Romania192 
QLocale::RussianFederationRussia 
QLocale::Russia193 
QLocale::Rwanda194 
QLocale::SaintBarthelemy195 
QLocale::SaintHelena196 
QLocale::SaintKittsAndNevis197 
QLocale::SaintLucia198 
QLocale::SaintMartin199 
QLocale::SaintPierreAndMiquelon200 
QLocale::SaintVincentAndGrenadines201 
QLocale::SaintVincentAndTheGrenadinesSaintVincentAndGrenadines 
QLocale::Samoa202 
QLocale::SanMarino203 
QLocale::SaoTomeAndPrincipe204 
QLocale::SaudiArabia205 
QLocale::Senegal206 
QLocale::Serbia207 
QLocale::Seychelles208 
QLocale::SierraLeone209 
QLocale::Singapore210 
QLocale::SintMaarten211 
QLocale::Slovakia212 
QLocale::Slovenia213 
QLocale::SolomonIslands214 
QLocale::Somalia215 
QLocale::SouthAfrica216 
QLocale::SouthGeorgiaAndSouthSandwichIslands217 
QLocale::SouthGeorgiaAndTheSouthSandwichIslandsSouthGeorgiaAndSouthSandwichIslands 
QLocale::SouthKorea218 
QLocale::SouthSudan219 
QLocale::Spain220 
QLocale::SriLanka221 
QLocale::Sudan222 
QLocale::Suriname223 
QLocale::SvalbardAndJanMayen224 
QLocale::SvalbardAndJanMayenIslandsSvalbardAndJanMayen 
QLocale::SwazilandEswatini 
QLocale::Sweden225 
QLocale::Switzerland226 
QLocale::Syria227 
QLocale::SyrianArabRepublicSyriaVeraltet, bitte stattdessen „ Syria “ verwenden
QLocale::Taiwan228 
QLocale::Tajikistan229 
QLocale::Tanzania230 
QLocale::Thailand231 
QLocale::TimorLeste232 
QLocale::Togo233 
QLocale::TokelauCountryTokelauTerritoryVeralteter Alias für TokelauTerritory
QLocale::TokelauTerritory (since Qt 6.2)234 
QLocale::Tonga235 
QLocale::TrinidadAndTobago236 
QLocale::TristanDaCunha237 
QLocale::Tunisia238 
QLocale::Turkey239 
QLocale::Turkmenistan240 
QLocale::TurksAndCaicosIslands241 
QLocale::TuvaluCountryTuvaluTerritoryVeralteter Alias für TuvaluTerritory
QLocale::TuvaluTerritory (since Qt 6.2)242 
QLocale::Uganda243 
QLocale::Ukraine244 
QLocale::UnitedArabEmirates245 
QLocale::UnitedKingdom246 
QLocale::UnitedStates248 
QLocale::UnitedStatesOutlyingIslands247 
QLocale::UnitedStatesMinorOutlyingIslandsUnitedStatesOutlyingIslands 
QLocale::UnitedStatesVirginIslands249 
QLocale::Uruguay250 
QLocale::Uzbekistan251 
QLocale::Vanuatu252 
QLocale::VaticanCity253 
QLocale::VaticanCityStateVaticanCity 
QLocale::Venezuela254 
QLocale::Vietnam255 
QLocale::WallisAndFutuna256 
QLocale::WallisAndFutunaIslandsWallisAndFutuna 
QLocale::WesternSahara257 
QLocale::World (since Qt 5.12)258 
QLocale::Yemen259 
QLocale::Zambia260 
QLocale::Zimbabwe261

Hinweis: Verwenden Sie für diese Aufzählung nach Möglichkeit den Alias „Territory“. Die Aufzählung „Country“ wird in einer späteren Version in „Territory“ umbenannt.

Siehe auch territory(), territoryToString(), codeToTerritory() und territoryToCode().

enum QLocale::CurrencySymbolFormat

Legt das Format des Währungssymbols fest.

KonstanteWertBeschreibung
QLocale::CurrencyIsoCode0ein ISO-4217-Code der Währung.
QLocale::CurrencySymbol1ein Währungssymbol.
QLocale::CurrencyDisplayName2Ein für den Benutzer lesbarer Name der Währung.

enum QLocale::DataSizeFormat
flags QLocale::DataSizeFormats

Legt das Format für die Darstellung von Datenmengen fest.

KonstanteWertBeschreibung
QLocale::DataSizeIecFormat0Format mit Basis 1024 und IEC-Präfixen: KiB, MiB, GiB, ...
QLocale::DataSizeTraditionalFormatDataSizeSIQuantifiersFormat mit Basis 1024 und SI-Vorgängern: kB, MB, GB, ...
QLocale::DataSizeSIFormatDataSizeBase1000 | DataSizeSIQuantifiersFormat mit Basis 1000 und SI-Präfixen: kB, MB, GB, ...

Der Typ „DataSizeFormats“ ist ein typedef für QFlags<DataSizeFormat>. Er speichert eine OR-Kombination von DataSizeFormat-Werten.

Siehe auch ` formattedDataSize()`.

enum QLocale::FloatingPointPrecisionOption

Diese Enumeration definiert eine Konstante, die bei der Konvertierung von Float- oder Double-Werten als Genauigkeit an die Funktionen ` QString::number()`, ` QByteArray::number()` und ` QLocale::toString()` übergeben werden kann, um eine variable Anzahl von Stellen als Genauigkeit anzugeben.

KonstanteWertBeschreibung
QLocale::FloatingPointShortest-128Der Konvertierungsalgorithmus versucht, die kürzeste genaue Darstellung für die angegebene Zahl zu finden. „Genau“ bedeutet, dass man bei einer umgekehrten Konvertierung der erzeugten Zeichenfolgendarstellung genau dieselbe Zahl zurückerhält. Insbesondere werden nachgestellte Nullen (in Exponentenformaten aus der Mantisse) weggelassen.

Siehe auch toString(), QString::number() und QByteArray::number().

enum QLocale::FormatType

Diese Enumeration beschreibt die verschiedenen Formate, die bei der Konvertierung von Objekten vom Typ „ QDate “, „ QTime “ und „ QDateTime “ sowie von Monaten und Tagen in lokalisierte Zeichenfolgen verwendet werden können.

KonstanteWertBeschreibung
QLocale::LongFormat0Längeres Format.
QLocale::ShortFormat1Kürzeres Format.
QLocale::NarrowFormat2Eine spezielle Version für den Einsatz bei sehr begrenztem Platz.

Hinweis: „ NarrowFormat “ kann für verschiedene Monate und Tage denselben Text enthalten. Es kann sogar eine leere Zeichenkette sein, wenn die Locale keine schmalen Namen unterstützt; daher sollten Sie die Verwendung für die Datumsformatierung vermeiden. Außerdem entspricht dieses Format für die System-Locale dem Format „ ShortFormat “.

Siehe auch dateFormat(), timeFormat(), dateTimeFormat(), monthName(), standaloneMonthName(), dayName(), standaloneDayName(), toDate(), toTime() und toDateTime().

enum QLocale::Language

Dieser Aufzählungstyp wird verwendet, um eine Sprache anzugeben.

KonstanteWertBeschreibung
QLocale::AnyLanguage0 
QLocale::C1Eine vereinfachte englische Ländereinstellung; siehe QLocale::c()
QLocale::Abkhazian2 
QLocale::AfanOromoVeraltet, bitte Oromo verwenden
QLocale::Afar3 
QLocale::Afrikaans4 
QLocale::Aghem5 
QLocale::Akan6 
QLocale::Akkadian (since Qt 5.1)7 
QLocale::Akoose (since Qt 5.3)8 
QLocale::Albanian9 
QLocale::AmericanSignLanguage (since Qt 5.7)10 
QLocale::Amharic11 
QLocale::AncientEgyptian (since Qt 5.1)12 
QLocale::AncientGreek (since Qt 5.1)13 
QLocale::Anii (since Qt 6.7)341 
QLocale::Arabic14 
QLocale::Aragonese (since Qt 5.1)15 
QLocale::Aramaic (since Qt 5.1)16 
QLocale::Armenian17 
QLocale::Assamese18 
QLocale::Asturian19 
QLocale::Asu20 
QLocale::Atsam21 
QLocale::Avaric22 
QLocale::Avestan23 
QLocale::Aymara24 
QLocale::Azerbaijani25 
QLocale::Bafia26 
QLocale::Balinese (since Qt 5.1)27 
QLocale::Baluchi (since Qt 6.6)337 
QLocale::Bambara28 
QLocale::Bamun (since Qt 5.1)29 
QLocale::Bangla (since Qt 6.0)30 
QLocale::Basaa31 
QLocale::Bashkir32 
QLocale::Basque33 
QLocale::BatakToba (since Qt 5.1)34 
QLocale::Belarusian35 
QLocale::Bemba36 
QLocale::Bena37 
QLocale::BengaliBanglaVeraltet, bitte „Bangla“ verwenden
QLocale::Bhojpuri (since Qt 5.7)38 
QLocale::BhutaniDzongkhaVeraltet, bitte „Dzongkha“ verwenden
QLocale::Bislama39 
QLocale::Blin40 
QLocale::Bodo41 
QLocale::Bosnian42 
QLocale::Breton43 
QLocale::Buginese (since Qt 5.1)44 
QLocale::Bulgarian45 
QLocale::Burmese46 
QLocale::ByelorussianBelarusianVeraltet, bitte verwenden Sie „Belarussisch“
QLocale::CambodianKhmerVeraltet, bitte Khmer verwenden
QLocale::Cantonese (since Qt 5.7)47 
QLocale::Catalan48 
QLocale::Cebuano (since Qt 5.14)49 
QLocale::CentralAtlasTamazight (since Qt 6.0)50 
QLocale::CentralKurdish (since Qt 5.5)51 
QLocale::CentralMoroccoTamazightCentralAtlasTamazightVeraltet, bitte CentralAtlasTamazight verwenden
QLocale::Chakma (since Qt 5.1)52 
QLocale::Chamorro53 
QLocale::Chechen54 
QLocale::Cherokee55 
QLocale::ChewaNyanjaVeraltet, bitte verwende Nyanja
QLocale::Chickasaw (since Qt 5.14)56 
QLocale::Chiga57 
QLocale::Chinese58(Mandarin)
QLocale::Church59 
QLocale::Chuvash60 
QLocale::Colognian61 
QLocale::Coptic (since Qt 5.1)62 
QLocale::Cornish63 
QLocale::Corsican64 
QLocale::Cree65 
QLocale::Croatian66 
QLocale::Czech67 
QLocale::Danish68 
QLocale::Divehi69 
QLocale::Dogri (since Qt 5.1)70 
QLocale::Duala71 
QLocale::Dutch72 
QLocale::Dzongkha73 
QLocale::Embu74 
QLocale::English75 
QLocale::Erzya (since Qt 5.14)76 
QLocale::Esperanto77 
QLocale::Estonian78 
QLocale::Ewe79 
QLocale::Ewondo80 
QLocale::Faroese81 
QLocale::Fijian82 
QLocale::Filipino83 
QLocale::Finnish84 
QLocale::French85 
QLocale::FrisianWesternFrisianwie Westfriesisch
QLocale::Friulian86 
QLocale::Fulah87 
QLocale::Ga89 
QLocale::Gaelic88 
QLocale::Galician90 
QLocale::Ganda91 
QLocale::Geez92 
QLocale::Georgian93 
QLocale::German94 
QLocale::Gothic (since Qt 5.1)95 
QLocale::Greek96 
QLocale::GreenlandicKalaallisutVeraltet, bitte verwenden Sie Kalaallisut
QLocale::Guarani97 
QLocale::Gujarati98 
QLocale::Gusii99 
QLocale::Haitian100 
QLocale::Haryanvi (since Qt 6.5)330 
QLocale::Hausa101 
QLocale::Hawaiian102 
QLocale::Hebrew103 
QLocale::Herero104 
QLocale::Hindi105 
QLocale::HiriMotu106 
QLocale::Hungarian107 
QLocale::Icelandic108 
QLocale::Ido (since Qt 5.12)109 
QLocale::Igbo110 
QLocale::InariSami (since Qt 5.5)111 
QLocale::Indonesian112 
QLocale::Ingush (since Qt 5.1)113 
QLocale::Interlingua114 
QLocale::Interlingue115 
QLocale::Inuktitut116 
QLocale::InupiakInupiaqVeraltet, bitte „Inupiaq“ verwenden
QLocale::Inupiaq (since Qt 6.0)117 
QLocale::Irish118 
QLocale::Italian119 
QLocale::Japanese120 
QLocale::Javanese121 
QLocale::Jju122 
QLocale::JolaFonyi123 
QLocale::Kabuverdianu124 
QLocale::Kabyle125 
QLocale::Kaingang (since Qt 6.3)328 
QLocale::Kako126 
QLocale::Kalaallisut (since Qt 6.0)127 
QLocale::Kalenjin128 
QLocale::Kamba129 
QLocale::Kangri (since Qt 6.7)342 
QLocale::Kannada130 
QLocale::Kanuri131 
QLocale::KaraKalpak (since Qt 6.9)345 
QLocale::Kashmiri132 
QLocale::Kazakh133 
QLocale::Kenyang (since Qt 5.5)134 
QLocale::Khmer135 
QLocale::Kiche (since Qt 5.5)136 
QLocale::Kikuyu137 
QLocale::Kinyarwanda138 
QLocale::KirghizKyrgyzVeraltet, bitte „Kirgisisch“ verwenden
QLocale::Komi139 
QLocale::Kongo140 
QLocale::Konkani141 
QLocale::Korean142 
QLocale::Koro143 
QLocale::KoyraboroSenni144 
QLocale::KoyraChiini145 
QLocale::Kpelle146 
QLocale::Kuanyama (since Qt 6.0)147 
QLocale::Kurdish148 
QLocale::KurundiRundiVeraltet, bitte Rundi verwenden
QLocale::Kuvi (since Qt 6.8)344 
QLocale::KwanyamaKuanyamaVeraltet, bitte Kuanyama verwenden
QLocale::Kwasio149 
QLocale::Kyrgyz (since Qt 6.0)150 
QLocale::Ladin (since Qt 6.11)347 
QLocale::Lakota (since Qt 5.3)151 
QLocale::Langi152 
QLocale::Lao153 
QLocale::Latin154 
QLocale::Latvian155 
QLocale::Lezghian (since Qt 5.5)156 
QLocale::Limburgish157 
QLocale::Lingala158 
QLocale::Ligurian (since Qt 6.6)338 
QLocale::LiteraryChinese (since Qt 5.7)159 
QLocale::Lithuanian160 
QLocale::Lojban (since Qt 5.12)161 
QLocale::LowerSorbian (since Qt 5.5)162 
QLocale::LowGerman163 
QLocale::LubaKatanga164 
QLocale::LuleSami (since Qt 5.5)165 
QLocale::Luo166 
QLocale::Luxembourgish167 
QLocale::Luyia168 
QLocale::Macedonian169 
QLocale::Machame170 
QLocale::Maithili (since Qt 5.5)171 
QLocale::MakhuwaMeetto172 
QLocale::Makonde173 
QLocale::Malagasy174 
QLocale::Malay176 
QLocale::Malayalam175 
QLocale::Maltese177 
QLocale::Mandingo (since Qt 5.1)178 
QLocale::Manipuri (since Qt 5.1)179 
QLocale::Manx180 
QLocale::Maori181 
QLocale::Mapuche (since Qt 5.5)182 
QLocale::Marathi183 
QLocale::Marshallese184 
QLocale::Masai185 
QLocale::Mazanderani (since Qt 5.7)186 
QLocale::Mende (since Qt 5.5)187 
QLocale::Meru188 
QLocale::Meta189 
QLocale::Mohawk (since Qt 5.5)190 
QLocale::Moksha (since Qt 6.5)333 
QLocale::Mongolian191 
QLocale::Morisyen192 
QLocale::Mundang193 
QLocale::Muscogee (since Qt 5.14)194 
QLocale::Nama195 
QLocale::NauruLanguage196 
QLocale::NavahoNavajoVeraltet, bitte „Navajo“ verwenden
QLocale::Navajo (since Qt 6.0)197 
QLocale::Ndonga198 
QLocale::Nepali199 
QLocale::Newari (since Qt 5.7)200 
QLocale::Ngiemboon201 
QLocale::Nheengatu (since Qt 6.3)329 
QLocale::NigerianPidgin (since Qt 6.0)203 
QLocale::Ngomba202 
QLocale::Nko (since Qt 5.5)204 
QLocale::NorthernFrisian (since Qt 6.5)331 
QLocale::NorthernLuri (since Qt 5.7)205 
QLocale::NorthernSami206 
QLocale::NorthernSotho207 
QLocale::NorthNdebele208 
QLocale::NorwegianBokmal209 
QLocale::NorwegianNynorsk210 
QLocale::Nuer211 
QLocale::Nyanja212 
QLocale::Nyankole213 
QLocale::Obolo (since Qt 6.5)336 
QLocale::Occitan214 
QLocale::Odia (since Qt 6.0)215 
QLocale::Ojibwa216 
QLocale::OldIrish (since Qt 5.1)217 
QLocale::OldNorse (since Qt 5.1)218 
QLocale::OldPersian (since Qt 5.1)219 
QLocale::OriyaOdiaVeraltet, bitte verwende Odia
QLocale::Oromo220 
QLocale::Osage (since Qt 5.7)221 
QLocale::Ossetic222 
QLocale::Pahlavi (since Qt 5.1)223 
QLocale::Palauan (since Qt 5.7)224 
QLocale::Pali225 
QLocale::Papiamento (since Qt 5.7)226 
QLocale::Pashto227 
QLocale::Persian228 
QLocale::Phoenician (since Qt 5.1)229 
QLocale::Pijin (since Qt 6.5)335 
QLocale::Polish230 
QLocale::Portuguese231 
QLocale::Prussian (since Qt 5.5)232 
QLocale::Punjabi233 
QLocale::Quechua234 
QLocale::Rajasthani (since Qt 6.5)332 
QLocale::RhaetoRomanceRomanshVeraltet, bitte Rätoromanisch verwenden
QLocale::Rohingya (since Qt 6.6)339 
QLocale::Romanian235 
QLocale::Romansh236 
QLocale::Rombo237 
QLocale::Rundi238 
QLocale::Russian239 
QLocale::Rwa240 
QLocale::Saho241 
QLocale::Sakha242 
QLocale::Samburu243 
QLocale::Samoan244 
QLocale::Sango245 
QLocale::Sangu246 
QLocale::Sanskrit247 
QLocale::Santali (since Qt 5.1)248 
QLocale::Sardinian249 
QLocale::Saurashtra (since Qt 5.1)250 
QLocale::Sena251 
QLocale::Serbian252 
QLocale::Shambala253 
QLocale::Shan (since Qt 6.11)348 
QLocale::Shona254 
QLocale::SichuanYi255 
QLocale::Sicilian (since Qt 5.12)256 
QLocale::Sidamo257 
QLocale::Silesian (since Qt 5.14)258 
QLocale::Sindhi259 
QLocale::Sinhala260 
QLocale::SkoltSami (since Qt 5.5)261 
QLocale::Slovak262 
QLocale::Slovenian263 
QLocale::Soga264 
QLocale::Somali265 
QLocale::SouthernKurdish (since Qt 5.12)266 
QLocale::SouthernSami (since Qt 5.5)267 
QLocale::SouthernSotho268 
QLocale::SouthNdebele269 
QLocale::Spanish270 
QLocale::StandardMoroccanTamazight (since Qt 5.3)271 
QLocale::Sundanese272 
QLocale::Swahili273 
QLocale::SwampyCree (since Qt 6.9)346 
QLocale::Swati274 
QLocale::Swedish275 
QLocale::SwissGerman276 
QLocale::Syriac277 
QLocale::Tachelhit278 
QLocale::Tahitian279 
QLocale::TaiDam (since Qt 5.1)280 
QLocale::Taita281 
QLocale::Tajik282 
QLocale::Tamil283 
QLocale::Taroko284 
QLocale::Tasawaq285 
QLocale::Tatar286 
QLocale::Telugu287 
QLocale::Teso288 
QLocale::Thai289 
QLocale::Tibetan290 
QLocale::Tigre291 
QLocale::Tigrinya292 
QLocale::TokelauLanguage (since Qt 5.7)293 
QLocale::TokiPona (since Qt 6.5)334 
QLocale::TokPisin (since Qt 5.7)294 
QLocale::Tongan295 
QLocale::Torwali (since Qt 6.6)340 
QLocale::Tsonga296 
QLocale::Tswana297 
QLocale::Turkish298 
QLocale::Turkmen299 
QLocale::TuvaluLanguage (since Qt 5.7)300 
QLocale::Tyap301 
QLocale::Ugaritic (since Qt 5.1)302 
QLocale::UighurUyghurVeraltet, bitte „Uyghur“ verwenden
QLocale::UigurUyghurVeraltet, bitte „Uyghur“ verwenden
QLocale::Ukrainian303 
QLocale::UpperSorbian (since Qt 5.5)304 
QLocale::Urdu305 
QLocale::Uyghur (since Qt 6.0)306 
QLocale::Uzbek307 
QLocale::Vai308 
QLocale::Venda309 
QLocale::Venetian (since Qt 6.7)343 
QLocale::Vietnamese310 
QLocale::Volapuk311 
QLocale::Vunjo312 
QLocale::WalamoWolayttaVeraltet, bitte Wolaytta verwenden
QLocale::Walloon313 
QLocale::Walser314 
QLocale::Warlpiri (since Qt 5.5)315 
QLocale::Welsh316 
QLocale::WesternBalochi (since Qt 5.12)317 
QLocale::WesternFrisian318wie im Friesischen
QLocale::Wolaytta (since Qt 6.0)319 
QLocale::Wolof320 
QLocale::Xhosa321 
QLocale::Yangben322 
QLocale::Yiddish323 
QLocale::Yoruba324 
QLocale::Zarma325 
QLocale::Zhuang326 
QLocale::Zulu327 

Siehe auch language() und languageToString().

enum QLocale::LanguageCodeType
flags QLocale::LanguageCodeTypes

Diese Enumeration definiert Sprachcode-Typen, mit denen sich die von codeToLanguage und languageToCode berücksichtigten Sprachcodes einschränken lassen.

KonstanteWertBeschreibung
QLocale::ISO639Part11 << 0ISO 639 Teil 1 Alpha-2-Code.
QLocale::ISO639Part2B1 << 1ISO 639 Teil 2: bibliografischer Alpha-3-Code.
QLocale::ISO639Part2T1 << 2ISO 639 Teil 2: Terminologischer Alpha-3-Code.
QLocale::ISO639Part31 << 3ISO 639 Teil 3 Alpha-3-Code.
QLocale::LegacyLanguageCode1 << 15Codes, die nicht Teil des oben genannten Satzes sind, aber in der Vergangenheit von Qt unterstützt wurden. Dieser Wert kann nur von ` codeToLanguage()` verwendet werden. Bei der Übergabe an ` languageToCode()` wird er ignoriert.
QLocale::ISO639Part2ISO639Part2B | ISO639Part2TBeliebiger ISO-639-Teil-2-Code.
QLocale::ISO639Alpha2ISO639Part1Beliebiger zweistelliger ISO-639-Code.
QLocale::ISO639Alpha3ISO639Part2 | ISO639Part3Beliebiger ISO-639-3-Buchstaben-Code.
QLocale::ISO639ISO639Alpha2 | ISO639Alpha3Beliebiger ISO-639-Code.
QLocale::AnyLanguageCode-1Gibt an, dass ein beliebiger Code verwendet werden kann.

Der Typ „LanguageCodeTypes“ ist ein typedef für QFlags<LanguageCodeType>. Er speichert eine ODER-Kombination von „LanguageCodeType“-Werten.

enum QLocale::MeasurementSystem

Diese Enumeration legt fest, welche Einheiten für die Messung verwendet werden.

KonstanteWertBeschreibung
QLocale::MetricSystem0Dieser Wert gibt metrische Einheiten wie Meter, Zentimeter und Millimeter auf Basis des SI an.
QLocale::ImperialUSSystem1Dieser Wert steht für imperiale Einheiten wie Zoll und Meilen, wie sie in den Vereinigten Staaten verwendet werden.
QLocale::ImperialUKSystem2Dieser Wert gibt imperiale Einheiten wie Zoll und Meilen an, wie sie im Vereinigten Königreich verwendet werden.
QLocale::ImperialSystemImperialUSSystemWird aus Kompatibilitätsgründen bereitgestellt. Entspricht „ImperialUSSystem“.

enum QLocale::NumberOption
flags QLocale::NumberOptions

Diese Enumeration definiert eine Reihe von Optionen für die Konvertierung von Zahlen in Zeichenfolgen und von Zeichenfolgen in Zahlen. Sie können mit ` numberOptions()` abgerufen und mit ` setNumberOptions()` festgelegt werden.

KonstanteWertBeschreibung
QLocale::DefaultNumberOptions0x0Diese Option entspricht dem Standardverhalten für alle Locales außer der C-Locale: mit Gruppentrennzeichen, mit einer führenden Null bei einstelligen Exponenten und ohne nachgestellte Nullen am Ende des Bruchteils (sofern vorhanden).
QLocale::OmitGroupSeparator0x01Ist diese Option gesetzt, teilen die Funktionen zur Umwandlung von Zahlen in Zeichenketten die Ziffern nicht in Gruppen auf. Die C-Locale setzt diese Option standardmäßig. Standardmäßig werden bei allen anderen Locales die Ziffern im ganzzahligen Teil einer Zahl mit Gruppentrennzeichen in Gruppen aufgeteilt.
QLocale::RejectGroupSeparator0x02Ist diese Option gesetzt, schlagen die Funktionen zur Umwandlung von Zeichenketten in Zahlen fehl, wenn sie in ihrer Eingabe Gruppentrennzeichen vorfinden. Standardmäßig werden Zahlen akzeptiert, die korrekt platzierte Gruppentrennzeichen enthalten.
QLocale::OmitLeadingZeroInExponent0x04Wenn diese Option gesetzt ist, fügen die Funktionen zur Umwandlung von Zahlen in Zeichenketten beim Ausgeben von Gleitkommazahlen in wissenschaftlicher Notation keine Nullen vor dem Exponenten ein. Standardmäßig wird bei einstelligen Exponenten eine führende Null hinzugefügt.
QLocale::RejectLeadingZeroInExponent0x08Wenn diese Option gesetzt ist, schlagen die Funktionen zur Umwandlung von Zeichenketten in Zahlen fehl, wenn sie beim Parsen einer Gleitkommazahl in wissenschaftlicher Notation auf einen mit Nullen aufgefüllten Exponenten stoßen. Standardmäßig wird eine solche Auffüllung akzeptiert.
QLocale::IncludeTrailingZeroesAfterDot0x10Wenn diese Option gesetzt ist, füllen die Funktionen zur Umwandlung von Zahlen in Zeichenfolgen Zahlen im „g“- oder „most concise“-Modus mit Nullen bis zur gewünschten Genauigkeit auf. Standardmäßig werden nachgestellte Nullen weggelassen, was dazu führen kann, dass der Bruchteil weniger Ziffern enthält als die geforderte Genauigkeit.
QLocale::RejectTrailingZeroesAfterDot0x20Wenn diese Option gesetzt ist, schlagen die Funktionen zur Umwandlung von Zeichenfolgen in Zahlen fehl, wenn sie beim Parsen einer Zahl in wissenschaftlicher oder dezimaler Darstellung auf nachgestellte Nullen am Ende des Bruchteils stoßen. Standardmäßig werden nachgestellte Nullen akzeptiert.

Der Typ „NumberOptions“ ist ein `typedef` für ` QFlags<NumberOption>`. Er speichert eine ODER-Kombination von `NumberOption`-Werten.

Siehe auch setNumberOptions(), numberOptions() und FloatingPointPrecisionOption.

enum QLocale::QuotationStyle

Diese Enumeration definiert eine Reihe möglicher Stile für lokales Zitieren.

KonstanteWertBeschreibung
QLocale::StandardQuotation0Wenn diese Option gesetzt ist, werden die Standard-Anführungszeichen zum Einrahmen von Zeichenketten verwendet.
QLocale::AlternateQuotation1Wenn diese Option gesetzt ist, werden die alternativen Anführungszeichen zum Einfassen von Zeichenketten verwendet.

Siehe auch ` quoteString()`.

enum QLocale::Script

Dieser Aufzählungstyp wird verwendet, um ein Skript anzugeben.

KonstanteWertBeschreibung
QLocale::AnyScript0 
QLocale::AdlamScript (since Qt 5.7)1 
QLocale::AhomScript (since Qt 5.7)2 
QLocale::AnatolianHieroglyphsScript (since Qt 5.7)3 
QLocale::ArabicScript4 
QLocale::ArmenianScript5 
QLocale::AvestanScript (since Qt 5.1)6 
QLocale::BalineseScript (since Qt 5.1)7 
QLocale::BamumScript (since Qt 5.1)8 
QLocale::BanglaScript (since Qt 6.0)9 
QLocale::BassaVahScript (since Qt 5.5)10 
QLocale::BatakScript (since Qt 5.1)11 
QLocale::BengaliScriptBanglaScriptVeraltet, bitte BanglaScript verwenden
QLocale::BhaiksukiScript (since Qt 5.7)12 
QLocale::BopomofoScript (since Qt 5.1)13 
QLocale::BrahmiScript (since Qt 5.1)14 
QLocale::BrailleScript (since Qt 5.1)15 
QLocale::BugineseScript (since Qt 5.1)16 
QLocale::BuhidScript (since Qt 5.1)17 
QLocale::CanadianAboriginalScript (since Qt 5.1)18 
QLocale::CarianScript (since Qt 5.1)19 
QLocale::CaucasianAlbanianScript (since Qt 5.5)20 
QLocale::ChakmaScript (since Qt 5.1)21 
QLocale::ChamScript (since Qt 5.1)22 
QLocale::CherokeeScript23 
QLocale::CopticScript (since Qt 5.1)24 
QLocale::CuneiformScript (since Qt 5.1)25 
QLocale::CypriotScript (since Qt 5.1)26 
QLocale::CyrillicScript27 
QLocale::DeseretScript (since Qt 5.1)28 
QLocale::DevanagariScript29 
QLocale::DuployanScript (since Qt 5.5)30 
QLocale::EgyptianHieroglyphsScript (since Qt 5.1)31 
QLocale::ElbasanScript (since Qt 5.5)32 
QLocale::EthiopicScript33 
QLocale::FraserScript (since Qt 5.1)34 
QLocale::GeorgianScript35 
QLocale::GlagoliticScript (since Qt 5.1)36 
QLocale::GothicScript (since Qt 5.1)37 
QLocale::GranthaScript (since Qt 5.5)38 
QLocale::GreekScript39 
QLocale::GujaratiScript40 
QLocale::GurmukhiScript41 
QLocale::HangulScript (since Qt 5.1)42 
QLocale::HanifiScript (since Qt 6.6)142 
QLocale::HanScript (since Qt 5.1)43 
QLocale::HanunooScript (since Qt 5.1)44 
QLocale::HanWithBopomofoScript (since Qt 5.7)45 
QLocale::HatranScript (since Qt 5.7)46 
QLocale::HebrewScript47 
QLocale::HiraganaScript (since Qt 5.1)48 
QLocale::ImperialAramaicScript (since Qt 5.1)49 
QLocale::InscriptionalPahlaviScript (since Qt 5.1)50 
QLocale::InscriptionalParthianScript (since Qt 5.1)51 
QLocale::JamoScript (since Qt 5.7)52 
QLocale::JapaneseScript53 
QLocale::JavaneseScript (since Qt 5.1)54 
QLocale::KaithiScript (since Qt 5.1)55 
QLocale::KannadaScript56 
QLocale::KatakanaScript (since Qt 5.1)57 
QLocale::KayahLiScript (since Qt 5.1)58 
QLocale::KharoshthiScript (since Qt 5.1)59 
QLocale::KhmerScript (since Qt 5.1)60 
QLocale::KhojkiScript (since Qt 5.5)61 
QLocale::KhudawadiScript (since Qt 5.5)62 
QLocale::KoreanScript63 
QLocale::LannaScript (since Qt 5.1)64 
QLocale::LaoScript65 
QLocale::LatinScript66 
QLocale::LepchaScript (since Qt 5.1)67 
QLocale::LimbuScript (since Qt 5.1)68 
QLocale::LinearAScript (since Qt 5.5)69 
QLocale::LinearBScript (since Qt 5.1)70 
QLocale::LycianScript (since Qt 5.1)71 
QLocale::LydianScript (since Qt 5.1)72 
QLocale::MahajaniScript (since Qt 5.5)73 
QLocale::MalayalamScript74 
QLocale::MandaeanScript (since Qt 5.1)75 
QLocale::ManichaeanScript (since Qt 5.5)76 
QLocale::MarchenScript (since Qt 5.7)77 
QLocale::MeiteiMayekScript (since Qt 5.1)78 
QLocale::MendeScript (since Qt 6.0)79 
QLocale::MendeKikakuiScriptMendeScriptVeraltet, bitte MendeScript verwenden
QLocale::MeroiticCursiveScript (since Qt 5.1)80 
QLocale::MeroiticScript (since Qt 5.1)81 
QLocale::ModiScript (since Qt 5.5)82 
QLocale::MongolianScript83 
QLocale::MroScript (since Qt 5.5)84 
QLocale::MultaniScript (since Qt 5.7)85 
QLocale::MyanmarScript86 
QLocale::NabataeanScript (since Qt 5.5)87 
QLocale::NewaScript (since Qt 5.7)88 
QLocale::NewTaiLueScript (since Qt 5.1)89 
QLocale::NkoScript (since Qt 5.1)90 
QLocale::OghamScript (since Qt 5.1)92 
QLocale::OlChikiScript (since Qt 5.1)93 
QLocale::OldHungarianScript (since Qt 5.7)94 
QLocale::OldItalicScript (since Qt 5.1)95 
QLocale::OldNorthArabianScript (since Qt 5.5)96 
QLocale::OldPermicScript (since Qt 5.5)97 
QLocale::OldPersianScript (since Qt 5.1)98 
QLocale::OldSouthArabianScript (since Qt 5.1)99 
QLocale::OdiaScript (since Qt 6.0)91 
QLocale::OriyaScriptOdiaScriptVeraltet, bitte OdiaScript verwenden
QLocale::OrkhonScript (since Qt 5.1)100 
QLocale::OsageScript (since Qt 5.7)101 
QLocale::OsmanyaScript (since Qt 5.1)102 
QLocale::PahawhHmongScript (since Qt 5.5)103 
QLocale::PalmyreneScript (since Qt 5.5)104 
QLocale::PauCinHauScript (since Qt 5.5)105 
QLocale::PhagsPaScript (since Qt 5.1)106 
QLocale::PhoenicianScript (since Qt 5.1)107 
QLocale::PollardPhoneticScript (since Qt 5.1)108 
QLocale::PsalterPahlaviScript (since Qt 5.5)109 
QLocale::RejangScript (since Qt 5.1)110 
QLocale::RunicScript (since Qt 5.1)111 
QLocale::SamaritanScript (since Qt 5.1)112 
QLocale::SaurashtraScript (since Qt 5.1)113 
QLocale::SharadaScript (since Qt 5.1)114 
QLocale::ShavianScript (since Qt 5.1)115 
QLocale::SiddhamScript (since Qt 5.5)116 
QLocale::SignWritingScript (since Qt 5.7)117 
QLocale::SimplifiedChineseScriptSimplifiedHanScriptentspricht der vereinfachten chinesischen Schrift
QLocale::SimplifiedHanScript118entspricht „SimplifiedChineseScript“
QLocale::SinhalaScript119 
QLocale::SoraSompengScript (since Qt 5.1)120 
QLocale::SundaneseScript (since Qt 5.1)121 
QLocale::SylotiNagriScript (since Qt 5.1)122 
QLocale::SyriacScript123 
QLocale::TagalogScript (since Qt 5.1)124 
QLocale::TagbanwaScript (since Qt 5.1)125 
QLocale::TaiLeScript (since Qt 5.1)126 
QLocale::TaiVietScript (since Qt 5.1)127 
QLocale::TakriScript (since Qt 5.1)128 
QLocale::TamilScript129 
QLocale::TangutScript (since Qt 5.7)130 
QLocale::TeluguScript131 
QLocale::ThaanaScript132 
QLocale::ThaiScript133 
QLocale::TibetanScript134 
QLocale::TifinaghScript135 
QLocale::TirhutaScript (since Qt 5.5)136 
QLocale::TraditionalChineseScriptTraditionalHanScriptentspricht der traditionellen Han-Schrift
QLocale::TraditionalHanScript137entspricht der traditionellen chinesischen Schrift
QLocale::UgariticScript (since Qt 5.1)138 
QLocale::VaiScript139 
QLocale::VarangKshitiScript (since Qt 5.5)140 
QLocale::YiScript141 

Siehe auch script(), scriptToString() und languageToString().

[since 6.7] enum class QLocale::TagSeparator

Erläutern Sie, wie die einzelnen Bestandteile einer Sprachumgebungskennung kombiniert werden.

Ein Sprachraumkennzeichen kann aus mehreren Tags bestehen, die Sprache, Schrift und Gebiet (sowie möglicherweise weitere Details) angeben und zu einem Kennzeichen zusammengefügt werden. Verschiedene Standards und konventionelle Formen verwenden entweder einen Bindestrich (das Unicode-Zeichen „HYPHEN-MINUS“, U+002D) oder einen Unterstrich (LOW LINE, U+005F). Verschiedene Clients von QLocale benötigen daher möglicherweise das eine oder das andere.

KonstanteWertBeschreibung
QLocale::TagSeparator::Dash'-'Verwenden Sie „ '-' “, das Bindestrich- oder Hyphen-Zeichen.
QLocale::TagSeparator::Underscore'_'Verwenden Sie „ '_' “, das Unterstrich-Zeichen.

Hinweis: Obwohl Bindestrich und Unterstrich die einzigen in öffentlichen Standards verwendeten Trennzeichen sind (Stand: 2023), ist es möglich, jedes beliebige ASCII- Zeichen in diesen Typ zu konvertieren, falls ein nicht standardmäßiges ASCII-Trennzeichen benötigt wird. Die Umwandlung eines Nicht-ASCII-Zeichens (mit einem Dezimalwert über 127) wird nicht unterstützt: Solche Werte sind für die zukünftige Verwendung als Enum-Elemente reserviert, falls ein öffentlicher Standard jemals ein Nicht-ASCII-Trennzeichen verwenden sollte. Es ist natürlich möglich, mit ` QString::replace()` das von einer Funktion, die einen Parameter dieses Typs akzeptiert, verwendete Trennzeichen durch ein beliebiges Unicode-Zeichen oder eine beliebige Zeichenkette zu ersetzen.

Diese Enumeration wurde in Qt 6.7 eingeführt.

[alias] QLocale::Territory

Dieser Aufzählungstyp ist ein Alias für „ Country “, der in einer zukünftigen Version in „Territory“ umbenannt werden soll.

Siehe auch „ territory()“ und „ territoryToString()“.

Dokumentation zu den Mitgliedsfunktionen

QLocale::QLocale()

Erstellt ein QLocale-Objekt, das mit der Standard-Locale initialisiert ist.

Wenn mit ` setDefault()` keine Standard-Locale festgelegt wurde, entspricht diese Locale derjenigen, die von ` system()` zurückgegeben wird.

Siehe auch setDefault() und system().

[explicit, since 6.3] QLocale::QLocale(QStringView name)

Erstellt ein QLocale-Objekt mit der angegebenen „ name “.

Der Name hat das Format „language[_script][_territory][.codeset][@modifier]“ oder „C“, wobei:

  • „language“ ein aus zwei Kleinbuchstaben bestehender ISO-639-Sprachcode ist (einige dreistellige Codes werden ebenfalls erkannt),
  • „script“ ein vierbuchstabiger, großgeschriebener ISO-15924-Schriftsystemcode ist,
  • „territory“ ein aus zwei Großbuchstaben bestehender ISO-3166-Gebietscode ist (einige numerische Codes werden ebenfalls erkannt) und
  • „codeset“ und „modifier“ werden ignoriert.

Als Trennzeichen kann entweder der Unterstrich '_' (U+005F, „Unterstrich“) oder der Bindestrich '-' (U+002D, „Bindestrich-Minus“) verwendet werden. Wenn QLocale keine Daten für die angegebene Kombination aus Sprache, Schrift und Gebiet hat, verwendet es stattdessen die am besten passende Übereinstimmung, die es finden kann. Wenn die Zeichenkette gegen das Locale-Format verstößt oder keine passenden Daten für die angegebenen Schlüssel gefunden werden können, wird stattdessen die Locale „C“ verwendet.

Dieser Konstruktor ist wesentlich langsamer als QLocale(Language, Script, Territory) oder QLocale(Language, Territory).

Diese Funktion wurde in Qt 6.3 eingeführt.

Siehe auch bcp47Name() und Matching combinations of language, script and territory.

QLocale::QLocale(QLocale::Language language, QLocale::Territory territory)

Erstellt ein QLocale-Objekt für die angegebenen Werte „ language “ und „ territory “.

Wenn für diese Kombination mehr als ein Skript verwendet wird, wird ein passendes Skript ausgewählt. Wenn QLocale keine Daten für die angegebene „ language “ enthält, wird die Standard-Locale verwendet. Wenn QLocale keine Daten für die angegebene Kombination aus „ language “ und „ territory “ enthält, kann stattdessen ein alternatives Gebiet verwendet werden.

Siehe auch setDefault() und Matching combinations of language, script and territory.

QLocale::QLocale(QLocale::Language language, QLocale::Script script = AnyScript, QLocale::Territory territory = AnyTerritory)

Erstellt ein QLocale-Objekt für die angegebenen Werte „ language “, „ script “ und „ territory “.

Wenn QLocale keine Daten für die angegebene Kombination enthält, sucht es nach Daten, die so gut wie möglich passen. Es greift auf die Standard-Locale zurück, wenn

  • language AnyLanguage ist und aus keine Sprache abgeleitet werden kann und script territory
  • QLocale keine Daten für die Sprache hat, sei es als „ language “ angegeben oder wie oben abgeleitet.

Siehe auch setDefault() und Matching combinations of language, script and territory.

[explicit] QLocale::QLocale(const QString &name)

Dies ist eine überladene Funktion.

[noexcept] QLocale::QLocale(const QLocale &other)

Erstellt ein QLocale-Objekt als Kopie von ` other`.

[noexcept] QLocale::~QLocale()

Destruktor

QString QLocale::amText() const

Gibt den lokalisierten Namen des Suffixes „AM“ für Zeiten zurück, die gemäß den Konventionen der 12-Stunden-Uhr angegeben wurden.

Siehe auch pmText().

QString QLocale::bcp47Name(QLocale::TagSeparator separator = TagSeparator::Dash) const

Gibt die BCP47-Feldnamen durch Bindestriche verbunden zurück.

Dabei werden so viele Felder aus den Bereichen „Sprache“, „Schrift“ und „Gebiet“ (sowie gegebenenfalls weitere BCP47-Felder) für diese Locale kombiniert, wie zur eindeutigen Spezifizierung erforderlich sind. Beachten Sie, dass Felder weggelassen werden können, wenn die „ Likely Subtag Rules “ des Unicode-Konsortiums die weggelassenen Felder implizieren, sobald die beibehaltenen Felder angegeben werden. Informationen dazu, wie aus einzelnen Feldern eine Zeichenkette gebildet werden kann, falls ein anderes Format benötigt wird, finden Sie unter name().

Im Gegensatz zu uiLanguages() stellt der von bcp47Name() zurückgegebene Wert den Locale-Namen der Daten aus QLocale dar; dies muss nicht unbedingt die Sprache sein, in der die Benutzeroberfläche angezeigt werden soll.

Diese Funktion versucht, den Locale-Namen an die IETF Best Common Practice 47 anzupassen, die in RFC 5646 definiert ist. Seit Qt 6.7 unterstützt sie einen optionalen Parameter ` separator `, mit dem die in BCP47 festgelegte Verwendung eines Bindestrichs zur Trennung der Tags überschrieben werden kann. Für die Verwendung in von der IETF definierten Protokollen sollte jedoch die Standardeinstellung „ QLocale::TagSeparator::Dash “ beibehalten werden.

Siehe auch name(), language(), territory(), script() und uiLanguages().

[static noexcept] QLocale QLocale::c()

Gibt ein „ QLocale “-Objekt zurück, das auf die Locale „C“ initialisiert ist.

Diese Locale basiert auf „en_US“, weist jedoch einige Eigenheiten auf, wie beispielsweise eine vereinfachte Zahlenformatierung und eine eigene Datumsformatierung. Sie implementiert die POSIX-Standards, die das Verhalten der Standardbibliotheksfunktionen der Programmiersprache „C“ beschreiben.

Das bedeutet unter anderem, dass die Sortierreihenfolge auf den ASCII-Werten der Buchstaben basiert, sodass (bei der Groß-/Kleinschreibung-sensitiven Sortierung) alle Großbuchstaben vor allen Kleinbuchstaben sortiert werden (anstatt dass die Groß- und Kleinbuchstabenformen eines Buchstabens nebeneinander sortiert werden, bevor die beiden Formen des nächsten Buchstabens folgen).

Siehe auch ` system()`.

[static noexcept, since 6.3] QLocale::Language QLocale::codeToLanguage(QStringView languageCode, QLocale::LanguageCodeTypes codeTypes = AnyLanguageCode)

Gibt die Enumeration „ QLocale::Language “ zurück, die dem zwei- oder dreistelligen Code „ languageCode “ entspricht, wie in den ISO 639-Normen definiert.

Falls angegeben, legt „ codeTypes “ fest, welche Codes für die Konvertierung berücksichtigt werden sollen. Standardmäßig werden alle Qt bekannten Codes berücksichtigt. Die Codes werden in der folgenden Reihenfolge abgeglichen: „ ISO639Part1 “, „ ISO639Part2B “, „ ISO639Part2T “, „ ISO639Part3 “, „ LegacyLanguageCode “.

Ist der Code ungültig oder unbekannt, wird „ QLocale::AnyLanguage “ zurückgegeben.

Diese Funktion wurde in Qt 6.3 eingeführt.

Siehe auch languageToCode(), codeToTerritory() und codeToScript().

[static noexcept, since 6.1] QLocale::Script QLocale::codeToScript(QStringView scriptCode)

Gibt die Enumeration „ QLocale::Script “ zurück, die der vierstelligen Schriftcode- scriptCode entspricht, wie sie in der Norm ISO 15924 definiert ist.

Ist der Code ungültig oder unbekannt, wird „ QLocale::AnyScript “ zurückgegeben.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch „ scriptToCode()“, „ codeToLanguage()“ und „ codeToTerritory()“.

[static noexcept, since 6.2] QLocale::Territory QLocale::codeToTerritory(QStringView territoryCode)

Gibt die Enumeration „ QLocale::Territory “ zurück, die dem zweibuchstabigen oder dreistelligen Ländercode „ territoryCode “ entspricht, wie er im ISO 3166-Standard definiert ist.

Ist der Code ungültig oder unbekannt, wird ` QLocale::AnyTerritory ` zurückgegeben.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch „ territoryToCode()“, „ codeToLanguage()“ und „ codeToScript()“.

QLocale QLocale::collation() const

Gibt die für die Sortierung zu verwendende Locale zurück.

Das Ergebnis ist in der Regel diese Locale; die System-Locale (die üblicherweise die Standard-Locale ist) gibt jedoch die System-Sortier-Locale zurück. Das Ergebnis eignet sich zur Übergabe an den Konstruktor von ` QCollator`.

Siehe auch QCollator.

QString QLocale::createSeparatedList(const QStringList &list) const

Gibt eine Zeichenkette zurück, die eine Verknüpfung einer vorgegebenen Zeichenkette „ list “ mit einem durch die Locale definierten Trennzeichen darstellt.

QString QLocale::currencySymbol(QLocale::CurrencySymbolFormat format = CurrencySymbol) const

Gibt ein Währungssymbol gemäß der Norm „ format “ zurück.

QString QLocale::dateFormat(QLocale::FormatType format = LongFormat) const

Gibt das für die aktuelle Ländereinstellung verwendete Datumsformat zurück.

Wenn „ format “ auf „ LongFormat “ gesetzt ist, ist das Format ausführlich, andernfalls ist es kurz. Beispielsweise lautet „ LongFormat “ für die Locale „ en_US “ „ dddd, MMMM d, yyyy “, „ ShortFormat “ lautet „ M/d/yy “.

Siehe auch QDate::toString() und QDate::fromString().

QString QLocale::dateTimeFormat(QLocale::FormatType format = LongFormat) const

Gibt das für die aktuelle Ländereinstellung verwendete Datums- und Zeitformat zurück.

Wenn „ format “ auf „ LongFormat “ gesetzt ist, ist das Format ausführlich, andernfalls ist es kurz. Beispielsweise lautet „ LongFormat “ für die Locale „ en_US “ „ dddd, MMMM d, yyyy h:mm:ss AP t “, „ ShortFormat “ lautet „ M/d/yy h:mm AP “.

Siehe auch QDateTime::toString() und QDateTime::fromString().

QString QLocale::dayName(int day, QLocale::FormatType type = LongFormat) const

Gibt den lokalisierten Namen des „ day “ zurück (wobei 1 für Montag, 2 für Dienstag usw. steht), und zwar in dem unter type angegebenen Format.

Wenn beispielsweise die Locale „ en_US “ lautet und „ day “ den Wert 1 hat, gibt „ LongFormat “ „ Monday “ zurück, „ ShortFormat “ „ Mon “ und „ NarrowFormat “ „ M “.

Siehe auch monthName() und standaloneDayName().

QString QLocale::decimalPoint() const

Gibt das Trennzeichen für den Bruchteil dieser Locale zurück.

Dies ist das Zeichen, das in der Darstellung einer Zahl mit Dezimalteil den ganzzahligen Teil vom Dezimalteil trennt. Es wird gemeinhin als „Dezimalpunktzeichen“ bezeichnet – auch wenn es in vielen Locales kein „Punkt“ (oder ähnliches Zeichen) ist. Es wird (seit Qt 6.0) als Zeichenkette zurückgegeben, falls eine Locale mehr als einen UTF-16-Codepunkt benötigt, um ihr Trennzeichen darzustellen.

Siehe auch groupSeparator() und toString().

QString QLocale::exponential() const

Gibt das Exponenten-Trennzeichen für diese Locale zurück.

Dies ist ein Token, das in einigen Darstellungen von Gleitkommazahlen zur Trennung von Mantisse und Exponent verwendet wird. Es wird (seit Qt 6.0) als Zeichenkette zurückgegeben, da es in manchen Locales nicht aus einem einzigen Zeichen besteht – beispielsweise kann es aus einem Multiplikationszeichen und einer Darstellung des Operators „Zehn hoch“ bestehen.

Siehe auch ` toString` (double, char, int).

Qt::DayOfWeek QLocale::firstDayOfWeek() const

Gibt den ersten Wochentag gemäß der aktuellen Ländereinstellung zurück.

QString QLocale::formattedDataSize(qint64 bytes, int precision = 2, QLocale::DataSizeFormats format = DataSizeIecFormat) const

Wandelt eine Größe in Byte in eine für Menschen lesbare, lokalisierte Zeichenfolge um, die aus einer Zahl und einer quantifizierten Einheit besteht. Der Quantor wird so gewählt, dass die Zahl mindestens eins beträgt und so klein wie möglich ist. Wenn beispielsweise bytes den Wert 16384 hat, precision den Wert 2 und format den Wert DataSizeIecFormat (Standard) angibt, gibt diese Funktion „16,00 KiB“ zurück; für 1330409069609 Byte gibt sie „1,21 GiB“ zurück; und so weiter. Wenn format auf DataSizeIecFormat oder DataSizeTraditionalFormat gesetzt ist, wird die angegebene Anzahl an Bytes durch eine Potenz von 1024 geteilt, wobei das Ergebnis kleiner als 1024 ist; bei DataSizeSIFormat wird sie durch eine Potenz von 1000 geteilt, wobei das Ergebnis kleiner als 1000 ist. DataSizeIecFormat verwendet die neuen IEC-Standardquantoren Ki, Mi usw., während DataSizeSIFormat die älteren SI-Quantoren k, M usw. verwendet und DataSizeTraditionalFormat diese missbraucht.

QString QLocale::groupSeparator() const

Gibt das Trennzeichen für die Zifferngruppierung für diese Ländereinstellung zurück.

Dies ist ein Token, das verwendet wird, um lange Ziffernfolgen in der Darstellung einer Zahl aufzuteilen, um die Lesbarkeit zu verbessern. In einigen Locales kann es leer sein, was bedeutet, dass Ziffern nicht auf diese Weise in Gruppen unterteilt werden sollen. In anderen kann es sich um ein Leerzeichen handeln. Es wird (seit Qt 6.0) als Zeichenkette zurückgegeben, falls eine Locale mehr als einen UTF-16-Codepunkt benötigt, um ihr Trennzeichen darzustellen.

Siehe auch decimalPoint() und toString().

QLocale::Language QLocale::language() const

Gibt die Sprache dieser Locale zurück.

Siehe auch script(), territory(), languageToString() und bcp47Name().

[static, since 6.3] QString QLocale::languageToCode(QLocale::Language language, QLocale::LanguageCodeTypes codeTypes = AnyLanguageCode)

Gibt den zwei- oder dreistelligen Sprachcode für language zurück, wie in den ISO 639-Normen definiert.

Falls angegeben, wählt „ codeTypes “ aus, welcher Satz von Codes berücksichtigt werden soll. Es wird der erste Code aus dem Satz zurückgegeben, der für „ language “ definiert ist. Andernfalls werden alle ISO-639-Codes berücksichtigt. Die Codes werden in der folgenden Reihenfolge berücksichtigt: „ ISO639Part1 “, „ ISO639Part2B “, „ ISO639Part2T “, „ ISO639Part3 “. „ LegacyLanguageCode “ wird von dieser Funktion ignoriert.

Hinweis: Für „ QLocale::C “ gibt die Funktion „ "C" “ zurück. Für „ QLocale::AnyLanguage “ wird eine leere Zeichenkette zurückgegeben. Wenn die Sprache in keinem der ausgewählten Zeichensätze einen Code hat, wird eine leere Zeichenkette zurückgegeben.

Diese Funktion wurde in Qt 6.3 eingeführt.

Siehe auch „ codeToLanguage()“, „ language()“, „ name()“, „ bcp47Name()“, „ territoryToCode()“ und „ scriptToCode()“.

[static] QString QLocale::languageToString(QLocale::Language language)

Gibt ein ` QString ` zurück, das den Namen von ` language` enthält.

Siehe auch territoryToString(), scriptToString() und bcp47Name().

[static] QList<QLocale> QLocale::matchingLocales(QLocale::Language language, QLocale::Script script, QLocale::Territory territory)

Gibt eine Liste gültiger Locale-Objekte zurück, die den angegebenen Werten language, script und territory entsprechen.

Abrufen einer Liste aller Locales: QList<QLocale> allLocales = QLocale::matchingLocales(QLocale::AnyLanguage, QLocale::AnyScript, QLocale::AnyTerritory);

Abrufen einer Liste der für Russland geeigneten Locales: QList<QLocale> locales = QLocale::matchingLocales(QLocale::AnyLanguage, QLocale::AnyScript, QLocale::Russia);

QLocale::MeasurementSystem QLocale::measurementSystem() const

Gibt das Maßsystem für die Gebietsschemaeinstellung zurück.

QString QLocale::monthName(int month, QLocale::FormatType type = LongFormat) const

Gibt den lokalisierten Namen von month im Format zurück, das unter type festgelegt ist.

Wenn beispielsweise die Locale „ en_US “ lautet und „ month “ den Wert 1 hat, gibt „ LongFormat “ „ January “ zurück. „ ShortFormat “ gibt „ Jan “ zurück und „ NarrowFormat “ gibt „ J “ zurück.

Siehe auch dayName() und standaloneMonthName().

QString QLocale::name(QLocale::TagSeparator separator = TagSeparator::Underscore) const

Der Kurzname dieser Locale.

Gibt die Sprache und das Gebiet dieser Locale als Zeichenkette der Form „language_territory“ zurück, wobei „language“ ein zweistelliger ISO-639-Sprachcode in Kleinbuchstaben und „territory“ ein zwei- oder dreistelliger ISO-3166-Gebietscode in Großbuchstaben ist. Wenn für die Locale kein Gebiet angegeben ist, wird nur der Sprachname zurückgegeben. Seit Qt 6.7 kann ein optionaler Parameter ` separator ` übergeben werden, um das standardmäßige Unterstrichzeichen zu überschreiben, das die beiden Tags trennt.

Selbst wenn das ` QLocale `-Objekt mit einem expliziten Skript erstellt wurde, enthält `name()` dieses aus Kompatibilitätsgründen nicht. Verwenden Sie stattdessen ` bcp47Name()` (), wenn Sie einen vollständigen Locale-Namen benötigen, oder bilden Sie die Zeichenkette, mit der Sie eine Locale identifizieren möchten, aus den zurückgegebenen Werten, indem Sie deren ` language()` an ` languageToCode()` übergeben – und verfahren Sie analog für das Skript und das Gebiet.

Siehe auch „ QLocale()“, „ language()“, „ script()“, „ territory()“, „ bcp47Name()“ und „ uiLanguages()“.

QString QLocale::nativeLanguageName() const

Gibt einen einheimischen Namen der Sprache für die Locale zurück. Zum Beispiel „Schweizer Hochdeutsch“ für die Locale „Schweizer Deutsch“.

Siehe auch nativeTerritoryName() und languageToString().

[since 6.2] QString QLocale::nativeTerritoryName() const

Gibt den einheimischen Namen des Gebiets für die Sprachumgebung zurück. Zum Beispiel „España“ für die Sprachumgebung „Spanisch/Spanien“.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch „ nativeLanguageName()“ und „ territoryToString()“.

QString QLocale::negativeSign() const

Gibt das Minuszeichen dieser Locale zurück.

Dies ist ein Token, das vermutlich als Präfix vor einer Zahl verwendet wird, um anzuzeigen, dass diese negativ ist. Es wird (seit Qt 6.0) als Zeichenkette zurückgegeben, da es in einigen Locales nicht aus einem einzigen Zeichen besteht – beispielsweise, weil es ein Zeichen zur Steuerung der Textrichtung enthält.

Siehe auch positiveSign() und toString().

QLocale::NumberOptions QLocale::numberOptions() const

Gibt die Optionen zurück, die sich auf Zahlenkonvertierungen für diese „ QLocale “-Instanz beziehen.

Standardmäßig sind für die Standard-Locales keine Optionen festgelegt, mit Ausnahme der Locale „C“, bei der standardmäßig „ OmitGroupSeparator “ gesetzt ist.

Siehe auch setNumberOptions(), toString(), groupSeparator() und FloatingPointPrecisionOption.

QString QLocale::percent() const

Gibt das Prozentzeichen dieser Locale zurück.

Dies ist ein Token, das vermutlich an eine Zahl angehängt wird, um einen Prozentsatz anzuzeigen. Es wird (seit Qt 6.0) als Zeichenkette zurückgegeben, da es in einigen Locales nicht aus einem einzigen Zeichen besteht – beispielsweise, weil es ein Zeichen zur Steuerung der Textrichtung enthält.

Siehe auch ` toString()`.

QString QLocale::pmText() const

Gibt den lokalisierten Namen des Suffixes „PM“ für Zeiten zurück, die gemäß den Konventionen der 12-Stunden-Uhr angegeben wurden.

Siehe auch amText().

QString QLocale::positiveSign() const

Gibt das Vorzeichen für positive Zahlen dieser Locale zurück.

Es handelt sich hierbei um ein Token, das vermutlich als Präfix vor einer Zahl verwendet wird, um anzuzeigen, dass diese positiv ist. Es wird (seit Qt 6.0) als Zeichenkette zurückgegeben, da es in einigen Locales nicht aus einem einzigen Zeichen besteht – beispielsweise, weil es ein Zeichen zur Steuerung der Textrichtung enthält.

Siehe auch negativeSign() und toString().

QString QLocale::quoteString(const QString &str, QLocale::QuotationStyle style = StandardQuotation) const

Gibt „ str “ zurück, das gemäß der aktuellen Locale unter Verwendung der angegebenen Anführungs style en formatiert ist.

[since 6.0] QString QLocale::quoteString(QStringView str, QLocale::QuotationStyle style = StandardQuotation) const

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.0 eingeführt.

QLocale::Script QLocale::script() const

Gibt das Skript dieser Locale zurück.

Siehe auch language(), territory(), languageToString(), scriptToString() und bcp47Name().

[static, since 6.1] QString QLocale::scriptToCode(QLocale::Script script)

Gibt den vierstelligen Schriftcode für „ script “ zurück, wie er in der Norm ISO 15924 definiert ist.

Hinweis: Für „ QLocale::AnyScript “ wird eine leere Zeichenkette zurückgegeben.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch „ script()“, „ name()“, „ bcp47Name()“, „ languageToCode()“ und „ territoryToCode()“.

[static] QString QLocale::scriptToString(QLocale::Script script)

Gibt ein ` QString ` zurück, das den Namen von ` script` enthält.

Siehe auch languageToString(), territoryToString(), script() und bcp47Name().

[static] void QLocale::setDefault(const QLocale &locale)

Legt die globale Standard-Locale auf „ locale “ fest.

Diese Locale wird verwendet, wenn ein ` QLocale `-Objekt ohne Argumente erstellt wird. Wird diese Funktion nicht aufgerufen, wird die System-Locale verwendet.

Warnung: In einer Multithread-Anwendung sollte die Standard-Locale beim Start der Anwendung festgelegt werden, bevor nicht-GUI-Threads erstellt werden.

Warnung: Diese Funktion ist nicht reentrant.

Siehe auch ` system()` und ` c()`.

void QLocale::setNumberOptions(QLocale::NumberOptions options)

Legt die „ options “ fest, die sich auf Zahlenkonvertierungen für diese „ QLocale “-Instanz beziehen.

Siehe auch ` numberOptions()` und ` FloatingPointPrecisionOption`.

QString QLocale::standaloneDayName(int day, QLocale::FormatType type = LongFormat) const

Gibt den lokalisierten Namen des Wochentags „ day “ zurück (wobei 1 für Montag, 2 für Dienstag usw. steht), der als eigenständiger Text verwendet wird, und zwar in dem unter type angegebenen Format.

Wenn die Lokalisierungsinformationen keinen eigenständigen Tagesnamen angeben, entspricht der Rückgabewert dem von ` dayName()`.

Siehe auch dayName() und standaloneMonthName().

QString QLocale::standaloneMonthName(int month, QLocale::FormatType type = LongFormat) const

Gibt den lokalisierten Namen von ` month ` zurück, der als eigenständiger Text verwendet wird, und zwar in dem Format, das unter type angegeben ist.

Wenn die Lokalisierungsinformationen keinen eigenständigen Monatsnamen angeben, entspricht der Rückgabewert dem von ` monthName()`.

Siehe auch ` monthName()` und ` standaloneDayName()`.

[noexcept] void QLocale::swap(QLocale &other)

Tauscht diese Ländereinstellung gegen „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

[static] QLocale QLocale::system()

Gibt ein „ QLocale “-Objekt zurück, das auf die System-Locale initialisiert ist.

Die System-Locale kann, sofern verfügbar, systemspezifische Quellen für Locale-Daten verwenden; andernfalls greift sie auf den integrierten Datenbankeintrag von „ QLocale “ für die vom System gemeldete Sprache, das Schriftzeichen und das Gebiet zurück.

Unter Windows und Mac verwendet diese Locale beispielsweise die im Systemkonfigurationsfenster festgelegten Dezimal- und Gruppierungszeichen sowie Datums- und Zeitformate.

Siehe auch c().

[since 6.2] QLocale::Territory QLocale::territory() const

Gibt das Gebiet dieser Locale zurück.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch language(), script(), territoryToString() und bcp47Name().

[static, since 6.2] QString QLocale::territoryToCode(QLocale::Territory territory)

Gibt den zweistelligen Ländercode für territory zurück, wie er im ISO 3166-Standard definiert ist.

Hinweis: Für QLocale::AnyTerritory wird eine leere Zeichenkette zurückgegeben.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch codeToTerritory(), territory(), name(), bcp47Name(), languageToCode() und scriptToCode().

[static, since 6.2] QString QLocale::territoryToString(QLocale::Territory territory)

Gibt ein ` QString ` zurück, das den Namen von ` territory` enthält.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch ` languageToString()`, ` scriptToString()`, ` territory()` und ` bcp47Name()`.

Qt::LayoutDirection QLocale::textDirection() const

Gibt die Textrichtung der Sprache zurück.

QString QLocale::timeFormat(QLocale::FormatType format = LongFormat) const

Gibt das für die aktuelle Ländereinstellung verwendete Zeitformat zurück.

Wenn ` format ` auf ` LongFormat` gesetzt ist, ist das Format ausführlich, andernfalls ist es kurz. Beispielsweise lautet ` LongFormat ` für die Locale ` en_US ` ` h:mm:ss AP t`, und ` ShortFormat ` ist ` h:mm AP`.

Siehe auch QTime::toString() und QTime::fromString().

QString QLocale::toCurrencyString(qlonglong value, const QString &symbol = QString()) const

Gibt eine lokalisierte Zeichenfolgendarstellung von „ value “ als Währung zurück. Wenn „ symbol “ angegeben wird, wird dieses anstelle des Standard-Währungssymbols verwendet.

Siehe auch currencySymbol().

QString QLocale::toCurrencyString(int value, const QString &symbol = QString()) const

Dies ist eine überladene Funktion.

QString QLocale::toCurrencyString(qulonglong value, const QString &symbol = QString()) const

Dies ist eine überladene Funktion.

QString QLocale::toCurrencyString(short value, const QString &symbol = QString()) const

Dies ist eine überladene Funktion.

QString QLocale::toCurrencyString(uint value, const QString &symbol = QString()) const

Dies ist eine überladene Funktion.

QString QLocale::toCurrencyString(ushort value, const QString &symbol = QString()) const

Dies ist eine überladene Funktion.

QString QLocale::toCurrencyString(double value, const QString &symbol = QString(), int precision = -1) const

Gibt eine lokalisierte Zeichenfolgendarstellung von value als Währung zurück. Wenn symbol angegeben wird, wird dieses anstelle des Standard-Währungssymbols verwendet. Wenn precision angegeben wird, wird dies verwendet, um die Genauigkeit des Währungswerts festzulegen.

Diese Funktion überlädt „ QLocale::toCurrencyString()“.

Siehe auch currencySymbol().

QString QLocale::toCurrencyString(float i, const QString &symbol = QString(), int precision = -1) const

Diese Funktion überlädt die Funktion „ QLocale::toCurrencyString()“.

QDate QLocale::toDate(const QString &string, QLocale::FormatType format = LongFormat, int baseYear = DefaultTwoDigitBaseYear) const

Liest „ string “ als Datum im lokalisierungsspezifischen Format „ format “.

Analysiert „ string “ und gibt das darin enthaltene Datum zurück. Das Format der Datumszeichenfolge richtet sich nach dem Parameter „ format “ (siehe dateFormat()).

Einige Locales verwenden, insbesondere für ShortFormat, nur die letzten beiden Ziffern des Jahres. In einem solchen Fall werden zunächst die 100 Jahre, die bei baseYear beginnen, als Kandidaten berücksichtigt. Vor Version 6.7 gab es keinen Parameter „ baseYear “ und es wurde immer das Jahr 1900 verwendet. Dies ist die Standardeinstellung für „ baseYear “, wobei ein Jahr zwischen diesem Zeitpunkt und 1999 ausgewählt wird. In einigen Fällen können andere Felder dazu führen, dass das nächste oder vorherige Jahrhundert ausgewählt wird, um ein Ergebnis zu erhalten, das mit allen angegebenen Feldern übereinstimmt. Weitere Informationen finden Sie unter QDate::fromString().

Hinweis: Monats- und Tagesnamen müssen, sofern verwendet, in der Sprache der Locale angegeben werden.

Wenn das Datum nicht analysiert werden konnte, wird ein ungültiges Datum zurückgegeben.

Siehe auch dateFormat(), toTime(), toDateTime() und QDate::fromString().

QDate QLocale::toDate(const QString &string, const QString &format, int baseYear = DefaultTwoDigitBaseYear) const

Liest „ string “ als Datum im angegebenen Format „ format “.

Analysiert „ string “ und gibt das Datum zurück, das es darstellt. Informationen zur Interpretation von „ format “ finden Sie unter „ QDate::fromString()“.

Wenn „ format “ nur die letzten beiden Ziffern eines Jahres angibt, werden zunächst die 100 Jahre, beginnend mit „ baseYear “, als mögliche Werte in Betracht gezogen. Vor Version 6.7 gab es keinen „ baseYear “-Parameter, und es wurde immer das Jahr 1900 verwendet. Dies ist die Standardeinstellung für „ baseYear “, wobei ein Jahr zwischen diesem Zeitpunkt und 1999 ausgewählt wird. In einigen Fällen können andere Felder dazu führen, dass das nächste oder vorherige Jahrhundert ausgewählt wird, um ein Ergebnis zu erhalten, das mit allen angegebenen Feldern übereinstimmt. Details finden Sie unter QDate::fromString().

Hinweis: Monats- und Tagesnamen müssen, sofern verwendet, in der Sprache der Locale angegeben werden.

Wenn das Datum nicht analysiert werden konnte, wird ein ungültiges Datum zurückgegeben.

Siehe auch dateFormat(), toTime(), toDateTime() und QDate::fromString().

QDate QLocale::toDate(const QString &string, QLocale::FormatType format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const

Dies ist eine überladene Funktion.

QDate QLocale::toDate(const QString &string, const QString &format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const

Dies ist eine überladene Funktion.

QDateTime QLocale::toDateTime(const QString &string, QLocale::FormatType format = LongFormat, int baseYear = DefaultTwoDigitBaseYear) const

Liest „ string “ als Datums- und Zeitangabe im lokalisierungsspezifischen Format „ format “.

Analysiert „ string “ und gibt das darin enthaltene Datum und die Uhrzeit zurück. Das Format der Datumszeichenfolge richtet sich nach dem Parameter „ format “ (siehe „ dateFormat()“).

Einige Sprachumgebungen verwenden, insbesondere für „ ShortFormat “, nur die letzten beiden Ziffern des Jahres. In einem solchen Fall werden zunächst die 100 Jahre ab „ baseYear “ in Betracht gezogen. Vor Version 6.7 gab es keinen Parameter „ baseYear “ und es wurde immer das Jahr 1900 verwendet. Dies ist die Standardeinstellung für „ baseYear “, wobei ein Jahr zwischen diesem Zeitpunkt und 1999 ausgewählt wird. In einigen Fällen können andere Felder dazu führen, dass das nächste oder vorherige Jahrhundert ausgewählt wird, um ein Ergebnis zu erhalten, das mit allen angegebenen Feldern übereinstimmt. Weitere Informationen finden Sie unter QDate::fromString().

Hinweis: Monats- und Tagesnamen müssen, sofern verwendet, in der Sprache der Locale angegeben werden. Alle verwendeten AM/PM-Angaben müssen mit amText() oder pmText() übereinstimmen, wobei die Groß-/Kleinschreibung ignoriert wird.

Wenn die Zeichenkette nicht geparst werden konnte, wird ein ungültiges ` QDateTime` zurückgegeben.

Siehe auch dateTimeFormat(), toTime(), toDate() und QDateTime::fromString().

QDateTime QLocale::toDateTime(const QString &string, const QString &format, int baseYear = DefaultTwoDigitBaseYear) const

Liest „ string “ als Datums- und Zeitangabe im angegebenen Format „ format “.

Analysiert „ string “ und gibt das darin enthaltene Datums- und Zeitformat zurück. Informationen zur Interpretation von „ format “ finden Sie unter „ QDateTime::fromString()“.

Wenn „ format “ nur die letzten beiden Ziffern eines Jahres angibt, werden zunächst die 100 Jahre, beginnend mit „ baseYear “, als Kandidaten in Betracht gezogen. Vor Version 6.7 gab es keinen Parameter „ baseYear “, und es wurde immer das Jahr 1900 verwendet. Dies ist die Standardeinstellung für „ baseYear “, wodurch ein Jahr zwischen diesem Zeitpunkt und 1999 ausgewählt wird. In einigen Fällen können andere Felder dazu führen, dass das nächste oder vorherige Jahrhundert ausgewählt wird, um ein Ergebnis zu erhalten, das mit allen angegebenen Feldern konsistent ist. Siehe QDate::fromString() für Details.

Hinweis: Monats- und Tagesnamen müssen, sofern verwendet, in der Sprache der Locale angegeben werden. Alle verwendeten AM/PM-Angaben müssen mit amText() oder pmText() übereinstimmen, wobei die Groß-/Kleinschreibung ignoriert wird.

Wenn die Zeichenkette nicht geparst werden konnte, wird ein ungültiges ` QDateTime` zurückgegeben. Wenn die Zeichenfolge analysiert werden kann und ein ungültiges Datums- und Zeitformat darstellt (z. B. in einer Lücke, die durch einen Zeitzonenwechsel übersprungen wurde), stellt das zurückgegebene ` QDateTime ` ein nahegelegenes Datums- und Zeitformat dar, das gültig ist (typischerweise unterscheidet es sich davon um die Breite der Lücke in gültigen Datums- und Zeitformaten, z. B. die durch einen Zeitzonenwechsel übersprungene Stunde). Wird dieser Wert an `fromMSecsSinceEpoch()` übergeben, ergibt sich ein gültiges Datums- und Zeitformat, das nicht originalgetreu durch die geparste Zeichenfolge dargestellt wird.

Siehe auch dateTimeFormat(), toTime(), toDate() und QDateTime::fromString().

QDateTime QLocale::toDateTime(const QString &string, QLocale::FormatType format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const

Dies ist eine überladene Funktion.

QDateTime QLocale::toDateTime(const QString &string, const QString &format, QCalendar cal, int baseYear = DefaultTwoDigitBaseYear) const

Dies ist eine überladene Funktion.

double QLocale::toDouble(QStringView s, bool *ok = nullptr) const

Gibt den Double-Wert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Gibt „unendlich“ zurück, wenn bei der Konvertierung ein Überlauf auftritt, oder 0,0, wenn die Konvertierung aus einem anderen Grund fehlschlägt (z. B. Unterlauf).

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

bool ok;
double d;

QLocale c(QLocale::C);
d = c.toDouble(u"1234.56", &ok);  // ok == true,  d == 1234.56
d = c.toDouble(u"1,234.56", &ok); // ok == true,  d == 1234.56
d = c.toDouble(u"1234,56", &ok);  // ok == false, d == 0

QLocale german(QLocale::German);
d = german.toDouble(u"1234,56", &ok);  // ok == true,  d == 1234.56
d = german.toDouble(u"1.234,56", &ok); // ok == true,  d == 1234.56
d = german.toDouble(u"1234.56", &ok);  // ok == false, d == 0

d = german.toDouble(u"1.234", &ok);    // ok == true,  d == 1234.0

Beachten Sie, dass die letzte Konvertierung 1234,0 zurückgibt, da „.“ in der deutschen Ländereinstellung das Tausendertrennzeichen ist.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toFloat(), toInt() und toString().

double QLocale::toDouble(const QString &s, bool *ok = nullptr) const

Gibt den Double-Wert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Gibt „unendlich“ zurück, wenn es bei der Konvertierung zu einem Überlauf kommt, oder 0,0, wenn die Konvertierung aus einem anderen Grund fehlschlägt (z. B. Unterlauf).

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

bool ok;
double d;

QLocale c(QLocale::C);
d = c.toDouble("1234.56", &ok);  // ok == true,  d == 1234.56
d = c.toDouble("1,234.56", &ok); // ok == true,  d == 1234.56
d = c.toDouble("1234,56", &ok);  // ok == false, d == 0

QLocale german(QLocale::German);
d = german.toDouble("1234,56", &ok);  // ok == true,  d == 1234.56
d = german.toDouble("1.234,56", &ok); // ok == true,  d == 1234.56
d = german.toDouble("1234.56", &ok);  // ok == false, d == 0

d = german.toDouble("1.234", &ok);    // ok == true,  d == 1234.0

Beachten Sie, dass die letzte Konvertierung 1234,0 zurückgibt, da „.“ in der deutschen Ländereinstellung das Tausendertrennzeichen ist.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toFloat(), toInt() und toString().

float QLocale::toFloat(QStringView s, bool *ok = nullptr) const

Gibt den Float-Wert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Gibt „unendlich“ zurück, wenn bei der Konvertierung ein Überlauf auftritt, oder 0,0, wenn die Konvertierung aus einem anderen Grund fehlschlägt (z. B. Unterlauf).

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toDouble(), toInt() und toString().

float QLocale::toFloat(const QString &s, bool *ok = nullptr) const

Gibt den Float-Wert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Gibt „unendlich“ zurück, wenn bei der Konvertierung ein Überlauf auftritt, oder 0,0, wenn die Konvertierung aus einem anderen Grund fehlschlägt (z. B. Unterlauf).

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachfolgende Leerzeichen.

Siehe auch toDouble(), toInt() und toString().

int QLocale::toInt(QStringView s, bool *ok = nullptr) const

Gibt die Ganzzahl zurück, die durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Wenn die Konvertierung fehlschlägt, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toUInt() und toString().

int QLocale::toInt(const QString &s, bool *ok = nullptr) const

Gibt die Ganzzahl zurück, die durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Wenn die Konvertierung fehlschlägt, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toUInt() und toString().

long QLocale::toLong(QStringView s, bool *ok = nullptr) const

Gibt den `long int`-Wert zurück, der durch die lokalisierte Zeichenkette „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toInt(), toULong(), toDouble() und toString().

long QLocale::toLong(const QString &s, bool *ok = nullptr) const

Gibt den `long int`-Wert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toInt(), toULong(), toDouble() und toString().

qlonglong QLocale::toLongLong(QStringView s, bool *ok = nullptr) const

Gibt den Wert vom Typ „long long int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toInt(), toULongLong(), toDouble() und toString().

qlonglong QLocale::toLongLong(const QString &s, bool *ok = nullptr) const

Gibt den Wert vom Typ `long long int` zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toInt(), toULongLong(), toDouble() und toString().

QString QLocale::toLower(const QString &str) const

Gibt eine Kopie von „ str “ in Kleinbuchstaben zurück.

Wenn „ Qt Core “ die ICU-Bibliotheken verwendet, werden diese herangezogen, um die Umwandlung gemäß den Regeln der aktuellen Locale durchzuführen. Andernfalls erfolgt die Umwandlung möglicherweise plattformabhängig, wobei „ QString::toLower()“ als generischer Fallback dient.

Siehe auch QString::toLower().

short QLocale::toShort(QStringView s, bool *ok = nullptr) const

Gibt den „short int“-Wert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Wenn die Konvertierung fehlschlägt, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toUShort() und toString().

short QLocale::toShort(const QString &s, bool *ok = nullptr) const

Gibt den `short int`-Wert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toUShort() und toString().

QString QLocale::toString(qlonglong i) const

Gibt eine lokalisierte Zeichenfolgendarstellung von i zurück.

Siehe auch toLongLong(), numberOptions(), zeroDigit() und positiveSign().

QString QLocale::toString(QTime time, QLocale::FormatType format = LongFormat) const

Gibt eine lokalisierte Zeichenfolgendarstellung des angegebenen „ time “ in der angegebenen „ format “ zurück (siehe timeFormat()).

QString QLocale::toString(QDate date, QLocale::FormatType format, QCalendar cal) const

Gibt eine lokalisierte Zeichenfolgendarstellung des angegebenen Datums „ date “ gemäß der angegebenen Datumsformatierung „ format “ zurück (siehe dateFormat()), optional für einen angegebenen Kalender „ cal “.

Hinweis: Einige Sprachumgebungen verwenden möglicherweise Formate, die den darstellbaren Jahresbereich einschränken. Die Verwendung zweistelliger Jahreszahlen in einigen Sprachumgebungen kann zu Mehrdeutigkeiten führen.

QString QLocale::toString(const QDateTime &dateTime, QLocale::FormatType format, QCalendar cal) const

Gibt eine lokalisierte Zeichenfolgendarstellung des angegebenen Datums und der Uhrzeit „ dateTime “ gemäß dem angegebenen Format „ format “ (siehe dateTimeFormat()) zurück, optional für einen angegebenen Kalender „ cal “.

Hinweis: Einige Locales verwenden möglicherweise Formate, die den darstellbaren Jahresbereich einschränken. Die Verwendung zweistelliger Jahreszahlen in einigen Locales kann zu Mehrdeutigkeiten führen.

QString QLocale::toString(const QDateTime &dateTime, QStringView format, QCalendar cal) const

Gibt eine lokalisierte Zeichenfolgendarstellung des angegebenen Datums und der Uhrzeit ( dateTime ) gemäß der angegebenen Datums- und Uhrzeitformatierung ( format ) zurück (siehe QDateTime::toString()), optional für einen angegebenen Kalender ( cal).

Ist ` format ` eine leere Zeichenkette, wird eine leere Zeichenkette zurückgegeben.

Siehe auch QDateTime::toString(), QDate::toString() und QTime::toString().

QString QLocale::toString(int i) const

Dies ist eine überladene Funktion.

Siehe auch toInt().

QString QLocale::toString(long i) const

Dies ist eine überladene Funktion.

Siehe auch toLong().

QString QLocale::toString(qulonglong i) const

Dies ist eine überladene Funktion.

Siehe auch toULongLong(), numberOptions(), zeroDigit() und positiveSign().

QString QLocale::toString(short i) const

Dies ist eine überladene Funktion.

Siehe auch toShort().

QString QLocale::toString(uint i) const

Dies ist eine überladene Funktion.

Siehe auch „ toUInt()“.

QString QLocale::toString(ulong i) const

Dies ist eine überladene Funktion.

Siehe auch toULong().

QString QLocale::toString(ushort i) const

Dies ist eine überladene Funktion.

Siehe auch toUShort().

QString QLocale::toString(QDate date, QLocale::FormatType format = LongFormat) const

Dies ist eine überladene Funktion.

QString QLocale::toString(QDate date, QStringView format) const

Dies ist eine überladene Funktion.

QString QLocale::toString(QDate date, const QString &format) const

Dies ist eine überladene Funktion.

QString QLocale::toString(QTime time, QStringView format) const

Dies ist eine überladene Funktion.

QString QLocale::toString(QTime time, const QString &format) const

Gibt eine lokalisierte Zeichenfolgendarstellung der angegebenen „ time “ gemäß der angegebenen „ format “ zurück (siehe „ QTime::toString()“).

Ist ` format ` eine leere Zeichenkette, wird eine leere Zeichenkette zurückgegeben.

Dies ist eine überladene Funktion.

Siehe auch dateFormat() und QTime::toString().

QString QLocale::toString(const QDateTime &dateTime, QLocale::FormatType format = LongFormat) const

Dies ist eine überladene Funktion.

QString QLocale::toString(const QDateTime &dateTime, QStringView format) const

Dies ist eine überladene Funktion.

QString QLocale::toString(const QDateTime &dateTime, const QString &format) const

Dies ist eine überladene Funktion.

QString QLocale::toString(QDate date, QStringView format, QCalendar cal) const

Gibt eine lokalisierte Zeichenfolgendarstellung des angegebenen Datums und der Uhrzeit „ date “ in der angegebenen Zeitform „ format “ zurück (siehe QDate::toString()), optional für einen angegebenen Kalender „ cal “.

Ist „ format “ eine leere Zeichenkette, wird eine leere Zeichenkette zurückgegeben.

Dies ist eine überladene Funktion.

Siehe auch dateFormat() und QDate::toString().

QString QLocale::toString(double f, char format = 'g', int precision = 6) const

Gibt eine Zeichenkette zurück, die die Gleitkommazahl f darstellt.

Die Form der Darstellung wird durch die Parameter „ format “ und „ precision “ gesteuert.

Der Standardwert für ` format ` ist ` 'g'`. Er kann einen der folgenden Werte annehmen:

FormatBedeutungBedeutung des precision
'e'Format wie [-]9,9e[+|-]999Anzahl der Stellen nach dem Komma
'E'Format als [-]9,9E[+|-]999"
'f'Formatierung als [-]9,9“
'F'entspricht „ 'f' “, mit Ausnahme von INF und NAN (siehe unten)"
'g'Verwende das Format „ 'e' “ oder „ 'f' “, je nachdem, welches prägnanter istmaximale Anzahl signifikanter Stellen (nachgestellte Nullen werden weggelassen)
'G'Verwenden Sie das Format „ 'E' “ oder „ 'F' “, je nachdem, welches prägnanter ist“

Der spezielle Wert „ precision “ QLocale::FloatingPointShortest wählt die kürzeste Darstellung aus, die, wenn sie als Zahl gelesen wird, den ursprünglichen Gleitkommawert liefert. Abgesehen davon wird jeder negative Wert für „ precision “ zugunsten des Standardwerts 6 ignoriert.

Bei den Formaten „ 'e' “, „ 'f' “ und „ 'g' “ wird die positive Unendlichkeit als „inf“, die negative Unendlichkeit als „-inf“ und Gleitkomma-NaN-Werte (Not-a-Number) als „nan“ dargestellt. Bei den Formaten „ 'E' “, „ 'F' “ und „ 'G' “ werden stattdessen „INF“ und „NAN“ verwendet. Dies ist unabhängig von der Ländereinstellung.

Dies ist eine überladene Funktion.

Siehe auch toDouble(), numberOptions(), exponential(), decimalPoint(), zeroDigit(), positiveSign(), percent(), toCurrencyString(), formattedDataSize() und QLocale::FloatingPointPrecisionOption.

QString QLocale::toString(float f, char format = 'g', int precision = 6) const

Gibt eine Zeichenkette zurück, die die Gleitkommazahl f darstellt.

Die Funktionen „ format “ und „ precision “ haben dieselbe Bedeutung wie unter toString(double, char, int) beschrieben.

Dies ist eine überladene Funktion.

Siehe auch toFloat(), toDouble(), numberOptions(), exponential(), decimalPoint(), zeroDigit(), positiveSign(), percent(), toCurrencyString(), formattedDataSize() und QLocale::FloatingPointPrecisionOption.

QString QLocale::toString(int number, int fieldWidth, char32_t fillChar) const

QString QLocale::toString(long number, int fieldWidth, char32_t fillChar) const

QString QLocale::toString(short number, int fieldWidth, char32_t fillChar) const

Gibt eine Zeichenkettendarstellung des angegebenen number zurück.

Die Länge der Zeichenkette muss mindestens dem Absolutwert von ` fieldWidth` entsprechen, wobei ` fillChar ` als Auffüllzeichen verwendet wird, wenn ` number ` weniger Ziffern enthält. Ist ` fillChar ` gleich ` '0' `, wird die Nullziffer dieser Locale als Auffüllzeichen verwendet. Ist fieldWidth negativ, beginnt die Zeichenfolge mit der Darstellung von number und wird, falls kürzer, mit dem angegebenen fillChar auf die Länge -fieldWidth aufgefüllt. Bei positivem fieldWidth erscheint die Auffüllung vor der Darstellung von number. Ist number negativ und fieldWidth positiv, wird – sofern fillChar ein '0' ist – die Auffüllung zwischen dem Minuszeichen dieser Locale und dem Beginn der Ziffern der Zahl eingefügt.

QString QLocale::toString(qlonglong number, int fieldWidth, char32_t fillChar) const

Gibt eine Zeichenkettendarstellung des angegebenen number zurück.

Die Länge der Zeichenkette muss mindestens dem Absolutwert von ` fieldWidth` entsprechen, wobei ` fillChar ` als Auffüllzeichen verwendet wird, falls ` number ` weniger Ziffern enthält. Ist ` fillChar ` gleich ` '0' `, wird die Nullziffer dieser Locale als Auffüllzeichen verwendet. Ist fieldWidth negativ, beginnt die Zeichenkette mit der Darstellung von number und wird, falls sie kürzer ist, mit dem angegebenen fillChar auf die Länge -fieldWidth aufgefüllt. Bei positiver fieldWidth erscheint die Auffüllung vor der Darstellung von number. Ist der number negativ und fieldWidth positiv, wird – sofern fillChar ein '0' ist – die Auffüllung zwischen dem Minuszeichen dieser Locale und dem Beginn der Ziffern der Zahl eingefügt.

Diese Funktion überlädt „ QLocale::toString()“.

QString QLocale::toString(qulonglong number, int fieldWidth, char32_t fillChar) const

Gibt eine Zeichenkettendarstellung des angegebenen number zurück.

Die Länge der Zeichenkette muss mindestens dem Absolutwert von ` fieldWidth` entsprechen, wobei ` fillChar ` als Auffüllzeichen verwendet wird, wenn ` number ` weniger Ziffern enthält. Ist ` fillChar ` gleich ` '0' `, wird die Nullziffer dieser Locale als Auffüllzeichen verwendet. Ist ` fieldWidth ` negativ, beginnt die Zeichenkette mit der Darstellung von ` number ` und wird, falls kürzer, mit dem angegebenen ` fillChar` auf die Länge ` -fieldWidth ` aufgefüllt. Bei positivem `fieldWidth` erscheint das Auffüllzeichen vor der Darstellung von ` number`.

Diese Funktion überlädt „ QLocale::toString()“.

QString QLocale::toString(uint number, int fieldWidth, char32_t fillChar) const

QString QLocale::toString(ulong number, int fieldWidth, char32_t fillChar) const

QString QLocale::toString(ushort number, int fieldWidth, char32_t fillChar) const

Gibt eine Zeichenkettendarstellung der angegebenen Zahl ` number` zurück.

Die Länge der Zeichenkette muss mindestens dem Absolutwert von ` fieldWidth` entsprechen, wobei ` fillChar ` als Auffüllzeichen verwendet wird, wenn ` number ` weniger Ziffern enthält. Ist ` fillChar ` gleich ` '0' `, wird die Nullziffer dieser Locale als Auffüllzeichen verwendet. Ist ` fieldWidth ` negativ, beginnt die Zeichenkette mit der Darstellung von ` number ` und wird, falls sie kürzer ist, mit dem angegebenen ` fillChar` auf die Länge ` -fieldWidth ` aufgefüllt. Bei positivem `fieldWidth` erscheint das Auffüllzeichen vor der Darstellung von ` number`.

QTime QLocale::toTime(const QString &string, QLocale::FormatType format = LongFormat) const

Liest „ string “ als Zeitangabe im lokalisierungsspezifischen Format „ format “.

Analysiert „ string “ und gibt die darin enthaltene Uhrzeit zurück. Das Format der Zeitangabe richtet sich nach dem Parameter „ format “ (siehe „ timeFormat()“).

Hinweis: Alle verwendeten AM/PM-Angaben müssen mit „ amText()“ oder „ pmText()“ übereinstimmen, wobei die Groß-/Kleinschreibung ignoriert wird.

Wenn die Zeit nicht analysiert werden konnte, wird eine ungültige Zeit zurückgegeben.

Siehe auch timeFormat(), toDate(), toDateTime() und QTime::fromString().

QTime QLocale::toTime(const QString &string, const QString &format) const

Liest „ string “ als Zeitangabe im angegebenen Format „ format “.

Analysiert string und gibt die darin enthaltene Uhrzeit zurück. Informationen zur Interpretation von format finden Sie unter QTime::fromString().

Hinweis: Alle verwendeten AM/PM-Angaben müssen mit „ amText()“ oder „ pmText “ übereinstimmen, wobei die Groß-/Kleinschreibung ignoriert wird.

Wenn die Zeitangabe nicht analysiert werden konnte, wird eine ungültige Zeit zurückgegeben.

Siehe auch timeFormat(), toDate(), toDateTime() und QTime::fromString().

uint QLocale::toUInt(QStringView s, bool *ok = nullptr) const

Gibt den Wert vom Typ „unsigned int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch „ toInt()“ und „ toString()“.

uint QLocale::toUInt(const QString &s, bool *ok = nullptr) const

Gibt den vorzeichenlosen Ganzzahlwert zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toInt() und toString().

ulong QLocale::toULong(QStringView s, bool *ok = nullptr) const

Gibt den Wert vom Typ „unsigned long int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toLong(), toInt(), toDouble() und toString().

ulong QLocale::toULong(const QString &s, bool *ok = nullptr) const

Gibt den Wert vom Typ „unsigned long int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht von „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toLong(), toInt(), toDouble() und toString().

qulonglong QLocale::toULongLong(QStringView s, bool *ok = nullptr) const

Gibt den Wert vom Typ „unsigned long long int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toLongLong(), toInt(), toDouble() und toString().

qulonglong QLocale::toULongLong(const QString &s, bool *ok = nullptr) const

Gibt den Wert vom Typ „unsigned long long int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toLongLong(), toInt(), toDouble() und toString().

ushort QLocale::toUShort(QStringView s, bool *ok = nullptr) const

Gibt den Wert vom Typ „unsigned short int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toShort() und toString().

ushort QLocale::toUShort(const QString &s, bool *ok = nullptr) const

Gibt den Wert vom Typ „unsigned short int“ zurück, der durch die lokalisierte Zeichenfolge „ s “ dargestellt wird.

Schlägt die Konvertierung fehl, gibt die Funktion 0 zurück.

Ist „ ok “ nicht „ nullptr “, wird ein Fehler gemeldet, indem *ok auf „ false “ gesetzt wird, und ein Erfolg, indem *ok auf „ true “ gesetzt wird.

Diese Funktion ignoriert führende und nachgestellte Leerzeichen.

Siehe auch toShort() und toString().

QString QLocale::toUpper(const QString &str) const

Gibt eine in Großbuchstaben geschriebene Kopie von str zurück.

Wenn „ Qt Core “ die ICU-Bibliotheken verwendet, werden diese eingesetzt, um die Umwandlung gemäß den Regeln der aktuellen Locale durchzuführen. Andernfalls erfolgt die Konvertierung möglicherweise plattformabhängig, wobei „ QString::toUpper()“ als generischer Fallback dient.

Hinweis: In einigen Fällen kann die Großbuchstabenform einer Zeichenkette länger sein als das Original.

Siehe auch QString::toUpper().

QStringList QLocale::uiLanguages(QLocale::TagSeparator separator = TagSeparator::Dash) const

Liste der Locale-Namen zur Auswahl von Übersetzungen

Jeder Eintrag in der zurückgegebenen Liste ist der Name einer Locale, die den Präferenzen des Benutzers hinsichtlich der Übersetzung der Benutzeroberfläche entspricht. Wenn ein Name in der Liste aus mehreren Tags besteht, werden diese wie in separator angegeben verbunden. Vor Qt 6.7 wurde ein Bindestrich als Trennzeichen verwendet.

Verwendet man beispielsweise das Standardtrennzeichen „ QLocale::TagSeparator::Dash “ und hat der Benutzer sein System so konfiguriert, dass US-Englisch verwendet wird, würde die Liste wie folgt aussehen: „en-Latn-US“, „en-US“, „en-Latn“, „en“. Die Reihenfolge der Einträge entspricht der Reihenfolge, in der nach Übersetzungen gesucht wird; frühere Einträge in der Liste haben Vorrang vor späteren. Wenn Ihre Übersetzungsdateien (oder andere lokalisierungsspezifische Ressourcen) Unterstriche anstelle von Bindestrichen zur Trennung von Lokalisierungs-Tags verwenden, übergeben Sie „ QLocale::TagSeparator::Underscore “ als „ separator “.

Gibt eine Liste mit Locale-Namen zurück. Diese kann mehrere Sprachen enthalten, insbesondere für die System-Locale, wenn mehrere Sprachen für die UI-Übersetzung konfiguriert sind. Die Reihenfolge der Einträge ist von Bedeutung. Für die System-Locale spiegelt sie beispielsweise die Benutzereinstellungen wider.

Vor Qt 6.9 enthielt die Liste nur explizit konfigurierte Locales und deren Entsprechungen. Dies führte dazu, dass einige Aufrufer Kürzungen (z. B. von „en-Latn-DE“ zu „en“) als Fallback-Optionen hinzufügten. Dies konnte manchmal zu ungeeigneten Auswahlen führen, insbesondere wenn diese vor späteren Einträgen ausprobiert wurden, die besser geeignete Fallback-Optionen darstellten.

Ab Qt 6.9 werden sinnvolle Verkürzungen in die zurückgegebene Liste aufgenommen, und zwar nach allen Einträgen, die den explizit angegebenen Locales entsprechen. Diese Änderung ermöglicht genauere Fallback-Optionen, ohne dass Aufrufer selbst Verkürzungen vornehmen müssen.

Benutzer können bevorzugte Fallback-Locales (wie z. B. „en-US“) explizit in ihre Systemkonfiguration aufnehmen, um die Reihenfolge der Präferenzen zu steuern. Es wird empfohlen, sich auf die Reihenfolge der Einträge in `uiLanguages()` zu verlassen, anstatt benutzerdefinierte Fallback-Methoden zu verwenden.

Höchstwahrscheinlich müssen Sie diese Funktion nicht direkt verwenden, sondern lediglich das ` QLocale `-Objekt an die Funktion ` QTranslator::load()` übergeben.

Siehe auch „ QTranslator “ und „ bcp47Name()“.

QList<Qt::DayOfWeek> QLocale::weekdays() const

Gibt eine Liste der Tage zurück, die gemäß der aktuellen Ländereinstellung als Wochentage gelten.

QString QLocale::zeroDigit() const

Gibt das Zeichen für die Ziffer „0“ dieser Locale zurück.

Es handelt sich um ein einzelnes Unicode-Zeichen, das jedoch als Surrogatpaar kodiert sein kann; daher wird es (seit Qt 6.0) als Zeichenkette zurückgegeben. In den meisten Locales folgen in der Unicode-Reihenfolge andere Ziffern darauf – einige Zahlensysteme, insbesondere solche, die U+3007 als Null verwenden, weisen jedoch keine zusammenhängenden Ziffern auf. Verwenden Sie ` toString()` (), um geeignete Darstellungen von Zahlen zu erhalten, anstatt zu versuchen, diese aus dieser Nullziffer zu konstruieren.

Siehe auch ` toString()`.

[noexcept] QLocale &QLocale::operator=(const QLocale &other)

Weist diesem QLocale -Objekt den Wert „ other “ zu und gibt eine Referenz auf dieses QLocale -Objekt zurück.

Dokumentation zu Member-Variablen

[since 6.7] const int QLocale::DefaultTwoDigitBaseYear

Diese Variable enthält das Standard-Startjahr des Jahrhunderts, aus dem ein Format, das eine zweistellige Jahresangabe akzeptiert, auswählt. Der Wert der Konstante lautet „ 1900 “.

Einige Sprachumgebungen verwenden, insbesondere für „ ShortFormat “, nur die letzten beiden Ziffern des Jahres. Vor Version 6.7 wurde in solchen Fällen stets das Jahr 1900 als Basisjahr verwendet. Nun verfügen verschiedene Funktionen wie „ QLocale “ und „ QDate “ über Überladungen, die es dem Aufrufer ermöglichen, das Basisjahr anzugeben, wobei diese Konstante als Standardwert verwendet wird.

Diese Variable wurde in Qt 6.7 eingeführt.

Siehe auch toDate(), toDateTime(), QDate::fromString() und QDateTime::fromString().

Verwandte Nicht-Mitglieder

[noexcept] size_t qHash(const QLocale &key, size_t seed = 0)

Gibt den Hash-Wert für key zurück, wobei seed als Startwert für die Berechnung verwendet wird.

[noexcept] bool operator!=(const QLocale &lhs, const QLocale &rhs)

Gibt „ true “ zurück, wenn sich die beiden Objekte „ QLocale “, „ lhs “ und „ rhs “, unterscheiden; andernfalls wird „ false “ zurückgegeben.

Hinweis: Die System-Locale ist nicht gleich dem Objekt ` QLocale `, das aus den Funktionen ` language()`, ` script()` und ` territory()` erstellt wurde, selbst wenn beide in allen Datenfeldern übereinstimmen. Auch zwei Locales mit unterschiedlichen Zahlenoptionen sind nicht gleich.

Siehe auch operator==() und setNumberOptions().

[noexcept] bool operator==(const QLocale &lhs, const QLocale &rhs)

Gibt „ true “ zurück, wenn die beiden Objekte „ QLocale “, „ lhs “ und „ rhs “, identisch sind; andernfalls wird „ false “ zurückgegeben.

Hinweis: Die System-Locale ist nicht gleich dem Objekt ` QLocale `, das aus den Funktionen ` language()`, ` script()` und ` territory()` erstellt wurde, selbst wenn beide in allen Datenfeldern übereinstimmen. Auch zwei Locales mit unterschiedlichen Zahlenoptionen sind nicht gleich.

Siehe auch operator!=() und setNumberOptions().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.