C++ Academy · Lezione

Algoritmi non modificanti: find, count, all_of

Cerchi e verifichi il contenuto dei contenitori senza modificarlo

Algoritmi non modificanti: find, count, all_of è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Operazioni di sola lettura

Gli algoritmi non modificanti esaminano un intervallo senza cambiarlo. Si trovano in <algorithm>.

std::find

Individua il primo elemento uguale a un valore. Restituisce un iteratore, oppure end se non viene trovato.

#include <algorithm>
std::vector<int> v = {3, 1, 4, 1, 5};
auto it = std::find(v.begin(), v.end(), 4);
if (it != v.end()) std::cout << "found at " << (it - v.begin());

std::find_if

Trova il primo elemento che soddisfa un predicato.

auto it = std::find_if(v.begin(), v.end(),
    [](int x) { return x > 3; });

std::find_if_not

È il complemento di find_if: restituisce il primo elemento che non soddisfa il predicato.

std::count e std::count_if

Contano le occorrenze o gli elementi che soddisfano un predicato. Restituiscono ptrdiff_t.

int n = std::count(v.begin(), v.end(), 1);            // count of 1s
int m = std::count_if(v.begin(), v.end(),
    [](int x) { return x > 2; });

std::all_of std::any_of std::none_of

Verificano un predicato sull'intervallo:

all_of — ogni elemento lo soddisfa
any_of — almeno un elemento lo soddisfa
none_of — nessun elemento lo soddisfa

bool allPositive = std::all_of(v.begin(), v.end(),
    [](int x) { return x > 0; });
bool anyEven = std::any_of(v.begin(), v.end(),
    [](int x) { return x % 2 == 0; });

std::equal

Confronta due intervalli elemento per elemento.

std::vector<int> a = {1, 2, 3};
std::vector<int> b = {1, 2, 3};
bool same = std::equal(a.begin(), a.end(), b.begin());

std::mismatch

Trova la prima coppia di elementi diversi tra due intervalli. Restituisce una coppia di iteratori.

std::adjacent_find

Trova la prima coppia di elementi adiacenti uguali (o che soddisfano un predicato).

std::vector<int> v = {1, 2, 2, 3};
auto it = std::adjacent_find(v.begin(), v.end());
std::cout << *it;   // 2

std::min_element std::max_element

Restituiscono un iteratore all'elemento più piccolo o più grande. Passate un predicato per usare un criterio di confronto diverso.

auto it = std::max_element(v.begin(), v.end());
std::cout << *it;

std::for_each

Chiama una funzione su ogni elemento. Il valore restituito dalla funzione viene ignorato.

std::for_each(v.begin(), v.end(),
    [](int x) { std::cout << x << " "; });

Versioni per i range (C++20)

C++20 ha aggiunto overload per i range che accettano un singolo range invece di due iteratori. La sintassi è più chiara.

#include <ranges>
auto it = std::ranges::find(v, 4);
bool ok = std::ranges::all_of(v, [](int x) { return x > 0; });

Verifica rapida

Quale algoritmo restituisce true solo se ogni elemento soddisfa un predicato?

Riepilogo

Gli algoritmi non modificanti esaminano gli intervalli senza cambiarli: find, count, all_of/any_of/none_of, min_element ed equal. I range di C++20 offrono una sintassi più chiara con un singolo intervallo.

Domande Frequenti

La lezione «Algoritmi non modificanti: find, count, all_of» è gratuita?

Sì — il testo completo di «Algoritmi non modificanti: find, count, all_of» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Algoritmi non modificanti: find, count, all_of»?

Cerchi e verifichi il contenuto dei contenitori senza modificarlo Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Algoritmi non modificanti: find, count, all_of»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Algoritmi non modificanti: find, count, all_of
Algoritmi modificanti: transform, copy_if, replace
Ordinamento e partizionamento: sort, stable_partition
Algoritmi numerici: accumulate, reduce, transform_reduce

← Torna a C++ Academy