Guia de C++ · 3/6
Por enquanto, este capítulo está disponível apenas em inglês.
C++ is statically typed: the type of every value is fixed at compile time. The compiler uses that knowledge both to catch mistakes and to generate fast code. This chapter tours the fundamental types, strings, the most common standard containers, and the ways you define your own types with classes, structs and scoped enums.
| Type | What it holds | Example |
|---|---|---|
bool | true or false | true, false |
char | a single byte-sized character | 'A' |
int | signed integer, commonly 32 bits | 42 |
long long | integer of at least 64 bits | 9'000'000'000LL |
double | double-precision floating point | 3.14 |
std::size_t | unsigned type for sizes and indices | what v.size() returns |
The standard only puts lower bounds on the size of int. When the exact width matters, use the fixed-width aliases from <cstdint> such as std::int32_t or std::uint64_t. The apostrophes inside a number are digit separators, available since C++14.
Prefer std::string from <string> over raw character arrays. It manages its own memory and knows its length.
#include <iostream>
#include <string>
int main() {
std::string s{"Hello"};
s += ", world"; // append
std::cout << s.size() << '\n'; // 12
std::cout << s.substr(0, 5) << '\n'; // "Hello"
if (auto pos = s.find("world"); pos != std::string::npos) {
std::cout << "found at " << pos << '\n';
}
int n = std::stoi("123"); // string to int
std::string t = std::to_string(n + 1); // int to string
}For read-only string parameters, take const std::string& or, since C++17, std::string_view. A string_view does not own its characters; it just points at someone else's, so it must never outlive the string it refers to.
| Container | When to use it |
|---|---|
std::vector<T> | Growable contiguous array. Your default choice |
std::array<T, N> | Fixed-size array with the size known at compile time |
std::map<K, V> | Associative container kept sorted by key |
std::unordered_map<K, V> | Hash table, no ordering, usually faster lookups |
#include <array>
#include <iostream>
#include <map>
#include <string>
#include <vector>
int main() {
std::vector<int> nums{3, 1, 4};
nums.push_back(1);
std::cout << nums.size() << ' ' << nums[0] << '\n'; // 4 3
std::array<double, 3> point{1.0, 2.0, 3.0};
std::cout << point.at(2) << '\n'; // at() checks the index
std::map<std::string, int> stock;
stock["apple"] = 5;
stock["banana"] = 2;
for (const auto& [name, qty] : stock) { // C++17 structured bindings
std::cout << name << ": " << qty << '\n';
}
if (stock.contains("apple")) { /* C++20 */ }
}operator[] on a vector does no bounds checking, and an out-of-range index is undefined behavior. Use at() or check the size when you aren't sure. Also note that operator[] on a std::map inserts a default-constructed value when the key is missing, which can surprise you during lookups.
A class bundles data (member variables) with behavior (member functions). Making the data private means only the class itself can modify it, so it can guarantee that its objects always stay in a valid state.
#include <stdexcept>
#include <string>
#include <utility>
class Account {
public:
explicit Account(std::string owner, long long balance = 0)
: owner_{std::move(owner)}, balance_{balance} { // member initializer list
if (balance_ < 0) throw std::invalid_argument("negative balance");
}
void deposit(long long amount) { balance_ += amount; }
long long balance() const { return balance_; } // const member function
const std::string& owner() const { return owner_; }
private:
std::string owner_;
long long balance_;
};
// Account a{"Kim", 1000};
// a.deposit(500); // a.balance() == 1500Constructors initialize members through the member initializer list after the colon. explicit stops a single-argument constructor from being used for implicit conversions you didn't ask for. Member functions that don't modify the object are marked const, which lets you call them on const objects and references.
The only language difference between struct and class is the default access: members of a struct are public. By convention, struct is used for plain bundles of data with no invariants to protect. For enumerations, prefer enum class: its enumerators are scoped and don't convert silently to integers.
#include <string>
enum class Color { Red, Green, Blue };
struct Pixel {
int x = 0;
int y = 0;
Color color = Color::Red;
};
std::string to_string(Color c) {
switch (c) {
case Color::Red: return "red";
case Color::Green: return "green";
case Color::Blue: return "blue";
}
return "unknown";
}
// Pixel p{10, 20, Color::Blue}; // aggregate initialization
// int raw = static_cast<int>(p.color); // explicit when you need the number<cstdint> fixed-width types when integer size matters.std::string; accept read-only text as const std::string& or std::string_view.std::vector first, std::array for fixed sizes, and std::map or std::unordered_map for key-value data.class with private members for types that enforce invariants, and a struct for plain data.enum class over plain enum.
0 comentários
Fazer login · Faça login para deixar um comentário.