C++11
Főnév
C++11 (tsz. C++11s)
A C++11 a C++ nyelv egyik legfontosabb frissítése, amely jelentős újításokat és fejlesztéseket vezetett be a nyelvben. Ez a szabvány 2011-ben jelent meg, és jelentősen megváltoztatta a C++ programozás módját. Az új funkciók közé tartoznak a fejlettebb memória- és többszálú programozási lehetőségek, az egyszerűbb szintaxis, valamint a teljesítményjavítások.
Ebben az útmutatóban részletesen bemutatjuk a C++11 legfontosabb újításait, és példákkal illusztráljuk azok használatát.
1. Automatikus típuslekövetés (auto)
Korábban minden változó típusát explicit módon kellett megadni. A C++11 bevezette az auto kulcsszót, amely lehetővé teszi a változók típusának automatikus kitalálását a fordító által.
Példa:
auto x = 10; // int
auto y = 3.14; // double
auto str = "Hello"; // const char*
Ez különösen akkor hasznos, ha egy hosszú és bonyolult típusnevű objektummal dolgozunk.
2. Típuslevezetés (decltype)
A decltype kulcsszó egy kifejezés típusát határozza meg fordítási időben.
Példa:
int a = 10;
decltype(a) b = 20; // b típusa int lesz
Ez különösen sablonprogramozásnál hasznos.
3. nullptr – Jobb nullmutató kezelés
A korábbi NULL makró helyett a C++11 bevezette a nullptr értéket, amely egy típusbiztos nullmutató.
Példa:
int* p = nullptr; // Biztonságosabb, mint NULL
4. Tartomány alapú for ciklus (range-based for loop)
A C++11 bevezette a tartomány alapú for ciklust, amely leegyszerűsíti az iterációt tömbökön és konténereken.
Példa:
#include <vector>
#include <iostream>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
std::cout << num << " ";
}
}
Kimenet: 1 2 3 4 5
5. Lambda kifejezések (lambda expressions)
A lambda kifejezések segítségével rövid és hatékony anonim függvényeket hozhatunk létre.
Példa:
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> numbers = {3, 1, 4, 1, 5, 9};
std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
return a < b;
});
for (int n : numbers) {
std::cout << n << " ";
}
}
Kimenet: 1 1 3 4 5 9
6. std::unique_ptr és std::shared_ptr – Modern memória kezelés
A C++11 okosmutatókat vezetett be a manuális memóriafelszabadítás kiküszöbölésére.
std::unique_ptr – Egyedüli tulajdonú mutató
#include <memory>
#include <iostream>
int main() {
std::unique_ptr<int> ptr = std::make_unique<int>(10);
std::cout << *ptr << std::endl;
}
std::shared_ptr – Megosztott tulajdonú mutató
#include <memory>
#include <iostream>
int main() {
std::shared_ptr<int> ptr1 = std::make_shared<int>(20);
std::shared_ptr<int> ptr2 = ptr1; // Több mutató is hivatkozhat rá
std::cout << *ptr1 << std::endl;
}
7. std::thread – Beépített többszálú programozás
A C++11 beépített többszálú támogatást vezetett be az std::thread osztállyal.
Példa:
#include <iostream>
#include <thread>
void printMessage() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
std::thread t(printMessage);
t.join(); // Megvárjuk a szál befejeződését
}
8. Mozaikos inicializálás (initializer_list)
Lehetővé teszi a konzisztens és egyszerűbb inicializálást.
Példa:
#include <vector>
#include <iostream>
int main() {
std::vector<int> vec = {1, 2, 3, 4, 5};
for (int n : vec) {
std::cout << n << " ";
}
}
9. std::to_string() – Egyszerűbb számból szöveggé alakítás
Korábban stringstream kellett a számból szöveggé alakításhoz, de C++11-ben jött az std::to_string().
Példa:
#include <iostream>
#include <string>
int main() {
int number = 42;
std::string str = std::to_string(number);
std::cout << str << std::endl;
}
10. enum class – Biztonságosabb felsorolási típus
A régi enum típusokkal szemben az enum class típusbiztos.
Példa:
enum class Color { Red, Green, Blue };
Color c = Color::Red; // Biztonságosabb, mint a sima enum
11. Rvalue hivatkozások és mozgás-szemantika (move semantics)
A C++11 bevezette a rvalue hivatkozásokat (&&), amelyek segítenek az erőforrások hatékony áthelyezésében.
Példa std::move használatával:
#include <iostream>
#include <vector>
int main() {
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = std::move(v1); // v1 tartalma átköltözik v2-be
}
Összegzés
A C++11 rengeteg új funkciót vezetett be, amelyek egyszerűsítették és gyorsabbá tették a programozást. A legfontosabb újdonságok közé tartoznak:
- Típuslekövetés (
auto,decltype) - Több szál támogatás (
std::thread) - Hatékony memória kezelés (
std::unique_ptr,std::shared_ptr) - Tömb- és konténerkezelés egyszerűsítése (
range-based for loop,initializer_list) - Lambda kifejezések
- Mozgás-szemantika és teljesítményoptimalizálás (
std::move)