C STL libstd - yszheda/wiki GitHub Wiki

template

Program initialization / exit

std::atexit

IO

istreambuf_iterator

std::ifstream stream("mona-lisa.raw", std::ios::in | std::ios::binary);
std::vector<uint8_t> contents((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());

ostream_iterator

// ostream_iterator example
#include <iostream>     // std::cout
#include <iterator>     // std::ostream_iterator
#include <vector>       // std::vector
#include <algorithm>    // std::copy

int main () {
  std::vector<int> myvector;
  for (int i=1; i<10; ++i) myvector.push_back(i*10);

  std::ostream_iterator<int> out_it (std::cout,", ");
  std::copy ( myvector.begin(), myvector.end(), out_it );
  return 0;
}
template<typename InputIt>
std::string join(InputIt begin,
                 InputIt end,
                 const std::string & separator =", ",  // see 1.
                 const std::string & concluder ="")    // see 1.
{
    std::ostringstream ss;

    using value_type = typename std::iterator_traits<InputIt>::value_type;

    std::copy(begin, end, std::ostream_iterator<value_type>(ss, separator.c_str()));

    ss << concluder;
    return ss.str();
}

Pitfalls

#include <string>
#include <vector>
#include <sstream>
#include <iterator>
#include <iostream>

std::string joint_strings(
    const std::vector<std::string>& str_vector,
    const char separator = ',',
    const char concluder = ';')
{
#if 1
  std::ostringstream ss;
  auto sep = std::string(&separator);
  std::copy(
      str_vector.begin(),
      str_vector.end(),
      // std::ostream_iterator<std::string>(ss, &separator));
      // std::ostream_iterator<std::string>(ss, ","));
      std::ostream_iterator<std::string>(ss, sep.c_str()));
  ss << concluder;
  return ss.str();
#else
  std::string result;
  for (const auto& str : str_vector)
  {
    result += str + separator;
  }
  result += concluder;
  return result;
#endif
}

int main()
{
  std::vector<std::string> str_vector;
  str_vector.push_back("GrpPowerOn");
  str_vector.push_back("0");

  for (auto i = 0; i < 10; i++)
  {
    auto str = joint_strings(str_vector);
    std::cout << "size: " << str.size() << " string: " << str << std::endl;
  }

  return 0;
}
$ ./a.out                  
size: 16 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;
size: 14 string: GrpPowerOn,0,;

streambuf

rdbuf

pubsetbuf

sgetn

std::ios::tie

sync_with_stdio

stringstream

std::stringstream().swap(m); // swap m with a default constructed stringstream

// Workaround gcc bug of not supporting `stringstream` swap and move
m.str(std::string());

stringstream::str()

compare with string concatenation

snprintf / vsnprintf

std::string

std::string::substr

std::regex

Performance

Container

std::array

Pass reference to std::array

initialize

std::array<std::array<int, 3>, 2> a2 { { { {1, 2, 3} }, { { 4, 5, 6} } } };
//                                   ^ ^ ^ ^            ^ ^
//                                   | | | |            | |
//                                   | +-|-+------------|-+
//                                   +-|-+-|------------+---- C++ class braces
//                                     |   |
//                                     +---+--- member C array braces

std::array of class without default ctor

std::dynarray valarray

std::list

splice

std::vector

release

split

resize for 2D vector

//vector<vector<int>> M;
//int m = number of rows, n = number of columns;
M.resize(m, vector<int>(n));

std::map

merge

targetMap.insert(sourceMap.begin(), sourceMap.end());

contains key

const / non-const key

emplace

enum class as key

struct EnumClassHash
{
    template <typename T>
    std::size_t operator()(T t) const
    {
        return static_cast<std::size_t>(t);
    }
};

enum class MyEnum {};

std::unordered_map<MyEnum, int, EnumClassHash> myMap;

pointer as key

reference std::reference_wrapper

change key

std::multimap

std::queue

iterator

std::iota

std::next_permutation

std::numeric_limits

// numeric_limits example
#include <iostream>     // std::cout
#include <limits>       // std::numeric_limits

int main () {
  std::cout << std::boolalpha;
  std::cout << "Minimum value for int: " << std::numeric_limits<int>::min() << '\n';
  std::cout << "Maximum value for int: " << std::numeric_limits<int>::max() << '\n';
  std::cout << "int is signed: " << std::numeric_limits<int>::is_signed << '\n';
  std::cout << "Non-sign bits in int: " << std::numeric_limits<int>::digits << '\n';
  std::cout << "int has infinity: " << std::numeric_limits<int>::has_infinity << '\n';
  return 0;
}

std::clamp

template<class T>
const T& clamp(const T& x, const T& upper, const T& lower) {
    return min(upper, max(x, lower));
}

std::remove_const

Math

std::ceil

Finite Num

round

#include <cfenv>
#include <cmath>
std::fesetround(FE_TONEAREST); // This is the default rounding mode for std::nearbyint
std::nearbyint(3.5f); // Result is 4
std::nearbyint(4.5f); // Result is 4

std::wstring

std::max_element

std::copy

std::memcmp

static int memvcmp(void *memory, unsigned char val, unsigned int size)
{
    unsigned char *mm = (unsigned char*)memory;
    return (*mm == val) && memcmp(mm, mm + 1, size - 1) == 0;
}

std::for_each

std::begin / std::end

std::transfer

std::swap

// assuming your vector is called v
iter_swap(v.begin() + position, v.begin() + nextPosition);
// position, nextPosition are the indices of the elements you want to swap

std::fill

std::min

std::copy

std::function

Solutions to std::function not equality comparable issue

Multi-thread

std::thread

error: no type named ‘type’ in ‘class std::result_of<std::_Mem_fn

std::condition_variable

std::mutex

std::call_once

thread safe

(Smart) Pointer

std::shared_ptr

std::weak_ptr

std::unique_ptr

release reset

std::make_unique

std::ref

std::uintptr_t

std::chrono

print current time/date

#include <iostream>
#include <chrono>
#include <ctime>    

int main()
{
    auto start = std::chrono::system_clock::now();
    // Some computation here
    auto end = std::chrono::system_clock::now();

    std::chrono::duration<double> elapsed_seconds = end-start;
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);

    std::cout << "finished computation at " << std::ctime(&end_time)
              << "elapsed time: " << elapsed_seconds.count() << "s\n";
}

#include <iostream>
#include <chrono>
#include <iomanip>
using namespace std;
using namespace chrono;

// Prints UTC timestamp
void printTime() {
    time_point<system_clock> now = system_clock::now();
    time_t now_time = system_clock::to_time_t(now);

    auto gmt_time = gmtime(&now_time);
    auto timestamp = std::put_time(gmt_time, "%Y-%m-%d %H:%M:%S");
    cout << timestamp << endl;
}

Algorithm

std::any_of

std::partial_sort

Filter: std::remove / std::remove_if / std::remove_copy_if / std::copy_if 

// Way #1
std::remove_copy_if(
  all_items.begin(), 
  all_items.end(), 
  std::back_inserter(filter_items),
  [&bad_ids](const mystruct& item) { return std::find(bad_ids.begin(), bad_ids.end(), item.id) != bad_ids.end(); });

// Way #2
all_items.erase(
  std::remove_if(
    all_items.begin(), 
    all_items.end(), 
    [&bad_ids](const mystruct& item) { return std::find(bad_ids.begin(), bad_ids.end(), item.id) != bad_ids.end(); }), 
  all_items.end());

type traits

std::is_pointer

std::is_same

namespace

is_trivial

value_type

std::conditional

std::variant (c++17)

RTTI

typeinfo

c++filt -t

Other libs

TR

expected

⚠️ **GitHub.com Fallback** ⚠️