std::transform

std::transform (tsz. std::transforms)

1. (informatika) A C++ nyelv Standard Template Library-jében (STL) számos hatékony algoritmust találunk, amelyek segítenek a gyakori műveletek elvégzésében. Ezek közé tartozik az std::transform is, amely egy nagyon rugalmas és gyakran használt algoritmus a <algorithm> fejlécben.

A std::transform fő célja az, hogy egy vagy két bemeneti tartomány elemein végighaladva transzformációt hajtson végre, és az eredményt egy kimeneti tartományba írja.

Az std::transform egy általános célú algoritmus, amely az elemeket egy adott függvény vagy függvénytárgy (functor, lambda, stb.) segítségével átalakítja.

Egyszerűen fogalmazva:

👉 Vesz egy (vagy két) tartományt → végighalad az elemeken → alkalmaz egy függvényt → az eredményt kiírja a kimeneti tartományba.

template<class InputIt, class OutputIt, class UnaryOperation>
OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first, UnaryOperation unary_op);

• first1, last1: a bemeneti tartomány kezdete és vége.
• d_first: a kimeneti tartomány kezdete (hova írjuk az eredményt).
• unary_op: egy egyváltozós függvény, amit az egyes bemeneti elemekre alkalmazunk.

template<class InputIt1, class InputIt2, class OutputIt, class BinaryOperation>
OutputIt transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first, BinaryOperation binary_op);

• first1, last1: az első bemeneti tartomány.
• first2: a második bemeneti tartomány kezdete.
• d_first: a kimeneti tartomány kezdete.
• binary_op: kétszárnyú függvény (binary operation), ami az első és második tartományból vett párokat dolgozza fel.

Az algoritmus az adott tartomány(ok) elemein iterátorokkal halad végig:

• Egyszeres verzió: unary_op(*it) → eredmény → kiírjuk.
• Páros verzió: binary_op(*it1, *it2) → eredmény → kiírjuk.

A std::transform nem módosítja a bemeneti tartományt! Csak a kimenetbe ír.

#include <iostream>
#include <vector>
#include <algorithm>  // transform
#include <iterator>   // back_inserter

int main() {
    std::vector<int> numbers{1, 2, 3, 4, 5};
    std::vector<int> squared;

    std::transform(numbers.begin(), numbers.end(), std::back_inserter(squared),
                   (int x) { return x * x; });

    for (int x : squared) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

Kimenet:

1 4 9 16 25

• numbers vektor → bemenet.
• Lambda: (int x) { return x * x; }
• Eredmény → squared vektorba íródik.

#include <iostream>
#include <string>
#include <algorithm>

int main() {
    std::string text = "HeLLo WoRLd!";
    std::string lower_text;

    lower_text.resize(text.size());

    std::transform(text.begin(), text.end(), lower_text.begin(),
                   (unsigned char c) { return std::tolower(c); });

    std::cout << lower_text << std::endl;
}

Kimenet:

hello world!

• std::tolower segítségével minden karaktert kisbetűsítünk.
• A std::transform karakterenként halad.

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> a{1, 2, 3, 4};
    std::vector<int> b{10, 20, 30, 40};
    std::vector<int> result;

    std::transform(a.begin(), a.end(), b.begin(), std::back_inserter(result),
                   (int x, int y) { return x + y; });

    for (int x : result) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

Kimenet:

11 22 33 44

• Két vektor pár elemeit összeadjuk.
• A binary_op egy kétszárnyú lambda.

Az std::transform nagyon rugalmas, tipikus használatai:

✅ elemek átalakítása (pl. szöveg feldolgozás) ✅ számítási műveletek (szorzás, összeadás, stb.) ✅ kombinációk két tartományból ✅ algoritmusokban adattisztítás ✅ adatformázás

A d_first iterátor lehet:

• egy iterator egy már létező tartományba
• vagy egy back_inserter → ilyenkor az eredmény automatikusan bővül

Példa back_inserter:

std::transform(vec.begin(), vec.end(), std::back_inserter(result), my_func);

Ha nem back_inserter, hanem sima iteratort adsz meg, a kimeneti tartománynak már helyet kell foglalnia (pl. resize-zel).

• Egyszerű, deklaratív kódot írhatunk.
• Hatékony: általában az STL algoritmusok optimalizáltak.
• Olvashatóság: a transzformáció logikája jól látható.

• Ha bonyolult mellékhatásokkal járna a lambda → jobb külön ciklus.
• Ha iterációs állapot kell, pl. index, számláló → ilyenkor sima for jobb.

Az std::transform egy nagyon hatékony eszköz, ha elemeket kell transzformálni tartományok között.

std::transform(first1, last1, d_first, unary_op);

std::transform(first1, last1, first2, d_first, binary_op);

• Rugalmas
• Könnyen olvasható
• STL standard algoritmus
• Széles körben alkalmazható

• Egyszerűbb ciklusoknál kissé “nehezebb” lehet olvasni kezdőként
• Mellékhatásos kód esetén nem ajánlott

• std::transform → elemek átalakítása egy vagy két tartományból egy másikba.
• std::transform nem módosítja a bemenetet.
• Ideális: adatformázás, feldolgozás, kombináció.
• Részét képezi a <algorithm> fejlécnek.

• std::transform - Szótár.net (en-hu)
• std::transform - Sztaki (en-hu)
• std::transform - Merriam–Webster
• std::transform - Cambridge
• std::transform - WordNet
• std::transform - Яндекс (en-ru)
• std::transform - Google (en-hu)
• std::transform - Wikidata
• std::transform - Wikipédia (angol)