Welcome to SwedenCpp

Latest blogs, videos, podcasts and releases in one stream

Tuesday, May 19, 2026

If this page is useful, please consider your support

Monday, May 18, 2026

Introducing the AI Code Documentation Skills for QtWriting reference documentation for Qt/C++ and QML code has traditionally meant either maintaining hand-written Markdown files that drift out of sync with the source or running toolchains that require annotated comment blocks throughout the codebase. The Qt documentation skills give developers a third option for higher productivity: point an AI agent at your source files and get structured, developer-ready Markdown reference docs in seconds.📝Qt Blog

Sunday, May 17, 2026

Saturday, May 16, 2026

How to join or concat ranges, C++26Modern C++ continuously improves its range library to provide more expressive, flexible, and efficient ways to manipulate collections. Usually, when you wanted to concatenate or flatten ranges, you’d use raw loops or custom algorithms. With C++’s range adaptors, we now have an elegant and efficient way to process collections lazily without unnecessary allocations. In this post, we will explore three powerful range adaptors introduced in different C++ standards: std::ranges::concat_view (C++26) std::ranges::join_view (C++20) std::ranges::join_with_view (C++23) Let’s break down their differences, use cases, and examples. Updated in May 2026: added from_range construction options. std::ranges::concat_view (C++26) The concat_view allows you to concatenate multiple independent ranges into a single sequence. Unlike join_view , it does not require a range of ranges-it simply merges the given ranges sequentially while preserving their structure. In short: Takes multiple independent ranges as arguments. Supports random access if all underlying ranges support it. Allows modification if underlying ranges are writable. Lazy evaluation: No additional memory allocations. See the example: #include #include #include #include int main () { std :: vector std :: string > v1 { "world" , "hi" }; std :: vector std :: string > v2 { "abc" , "xyz" }; std :: string arr []{ "one" , "two" , "three" }; auto v1_rev = v1 | std :: views :: reverse ; auto concat = std :: views :: concat ( v1_rev , v2 , arr ); concat [ 0 ] = "hello" ; // access and write for ( auto & elem : concat ) std :: print ( "{} " , elem ); } See at @Compiler Explorer The output: hello world abc xyz one two three The example below shows how to concatenate three ranges, v1 is reversed and then combined with v2 and arr. Notice that we can also access the value at position 0 and update it. And a bit more complex example: #include #include #include #include #include struct Transaction { std :: string type ; double amount ; }; int main () { std :: vector Transaction > bank_transactions { { "Deposit" , 100.0 }, { "Withdraw" , 50.0 }, { "Deposit" , 200.0 } }; std :: list Transaction > credit_card_transactions { { "Charge" , 75.0 }, { "Payment" , 50.0 } }; auto filtered_bank = bank_transactions | std :: views :: filter ([]( const Transaction & t ) { return t . amount >= 100.0 ; }); auto filtered_credit = credit_card_transactions | std :: views :: filter ([]( const Transaction & t ) { return t . amount > 60.0 ; }); auto all_transactions = std :: views :: concat ( filtered_bank , filtered_credit ); for ( const auto & t : all_transactions ) std :: println ( "{} - {}$" , t . type , t . amount ); } Run @Compiler Explorer std::ranges::join_view (C++20) The join_view is designed for flattening a single range of ranges into a single sequence. It removes the structural boundaries between nested ranges. Works on a single range of ranges (e.g., std::vector > ). Does not support operator[] (no random access). Eliminates boundaries between sub-ranges. Lazy evaluation, avoiding memory copies. A simple example: #include #include #include int main () { std :: vector std :: vector int >> nested {{ 1 , 2 }, { 3 , 4 , 5 }, { 6 , 7 }}; auto joined = std :: views :: join ( nested ); for ( int i : joined ) std :: println ( i ); } Run @Compiler Explorer The output: 1 2 3 4 5 6 7 Of course, we can have different nested ranges… and this can be handy for string processing: #include #include #include #include #include int main () { std :: vector std :: string > words { "Hello" , "World" , "Coding" }; // regular: std :: map char , int > freq ; for ( auto & w : words ) for ( auto & c : w ) freq [ :: tolower ( c )] ++ ; // join: std :: map char , int > freq2 ; for ( auto & c : words | std :: views :: join ) freq2 [ :: tolower ( c )] ++ ; for ( auto & [ key , val ] : freq2 ) std :: println ( "{} -> {}" , key , val ); } Run @Compiler Explorer As you can see, thanks to views_join we can save one nested loop and iterate through a single range of characters. std::ranges::join_with_view (C++23) The join_with_view works like join_view , but it allows inserting a delimiter between flattened sub-ranges. Works on a single range of ranges. Allows specifying a delimiter (single element or a range). Does not support random access. Useful for formatting strings or separating collections. See the example below: #include #include #include #include #include std :: string to_uppercase ( std :: string_view word ) { std :: string result ( word ); for ( char & c : result ) c = std :: toupper ( static_cast unsigned char > ( c )); return result ; } int main () { std :: vector std :: string_view > words { "The" , "C++" , "ranges" , "library" }; auto words_up = words | std :: views :: transform ( to_uppercase ); auto joined = std :: views :: join_with ( words_up , std :: string_view ( " " )); for ( auto c : joined ) std :: cout c ; } See at Compiler Explorer Here’s the expected output: THE C++ RANGES LIBRARY Creating new containers from the view I think I overlooked one important aspect of our experiments. It’s good that we can print flattened or concatenated ranges… but what if you want to create another container from that view? A simple example could be as follows: std :: vector int > make_flat ( const std :: vector std :: vector int >> & nested ) { // ?? } auto new_vector = make_flat ( vec_vec ); We have at least four options here: Before C++23, we can push data to the new container in some loop, Or pass begin() and end() iterators, For C++23, we can use ranges::to() , Or, also for C++23, create container directly from a range/view. See the example here: #include #include #include #include #include std :: vector int > make_flat_loop ( const std :: vector std :: vector int >>& nested ) { std :: vector int > out ; for ( int value : nested | std :: views :: join ) out . push_back ( value ); return out ; } std :: vector int > make_flat_iters ( const std :: vector std :: vector int >>& nested ) { auto joined = nested | std :: views :: join ; return { joined . begin (), joined . end () }; } std :: vector int > make_flat_to ( const std :: vector std :: vector int >>& nested ) { return nested | std :: views :: join | std :: ranges :: to std :: vector int >> (); } std :: vector int > make_flat_from_range ( const std :: vector std :: vector int >>& nested ) { auto joined = nested | std :: views :: join ; return std :: vector int > ( std :: from_range , joined ); } int main () { std :: vector std :: vector int >> nested {{ 1 , 2 }, { 3 , 4 , 5 }, { 6 , 7 }}; auto flat1 = make_flat_loop ( nested ); auto flat2 = make_flat_iters ( nested ); auto flat3 = make_flat_to ( nested ); auto flat4 = make_flat_from_range ( nested ); for ( auto && flat : { flat1 , flat2 , flat3 , flat4 }) { for ( int value : flat ) std :: print ( "{} " , value ); std :: println ( "" ); } std :: vector std :: string > words { "C++" , "ranges" , "are" , "powerful" }; auto sentence = std :: string ( std :: from_range , std :: views :: join_with ( words , std :: string_view ( " " )) ); std :: println ( "{}" , sentence ); } See @Compiler Explorer The output: 1 2 3 4 5 6 7 1 2 3 4 5 6 7 1 2 3 4 5 6 7 1 2 3 4 5 6 7 C++ ranges are powerful The C++23 changes came from the following proposal: P1206R7 - Conversions from ranges to containers . Comparing concat_view , join_view , and join_with_view Feature concat_view ✅ join_view ✅ join_with_view ✅ Works on multiple independent ranges? ✅ ❌ ❌ Flattens nested ranges? ❌ ✅ ✅ Supports separators between sub-ranges? ❌ ❌ ✅ Random access support? ✅ (if all inputs support it) ❌ ❌ Summary C++’s range adaptors provide efficient ways to manipulate collections without unnecessary copying. Here’s a quick summary of when to use each view: Use concat_view when merging multiple independent ranges. Use join_view when flattening a range of ranges. Use join_with_view when flattening a range of ranges but needing a separator between elements. References Books: C++23 Best Practices - by Jason Turner Modern C++ Programming Cookbook - by Marius Bancila Programming: Principles and Practice Using C++ - by Bjarne Stroustrup Other: std::ranges::join_view - cppreference.com std::ranges::join_with_view - cppreference.com std::ranges::concat_view - cppreference.com Back to you Do you use ranges? What are your most useful views ald algorithms on ranges? Share your comments below📝C++ Stories

Friday, May 15, 2026

Thursday, May 14, 2026

Wednesday, May 13, 2026