modify (+1), по факту там будет лежать отложенное вычисление на миллион прибавлений единиц, что будет кушать память. Потому есть строгая монада state, а также modify', который форсирует применение переданной функции.
PS> $out = (qwinsta)
PS> $len = ($out | select -First 1 | ? { $_ -match '.*(ID)' } | % { $matches[0].Length })
PS> $out | select -skip 1 | % { $_.Substring(0, $len) } | ? { $_ -match '(\d+)$' } | % { $matches[1] }
0
2
65537main должна иметь тип IO t, где t — любой тип, результат будет проигнорирован. Чтобы вернуть exitcode отличный от нуля, надо пользоваться соответствующими функциями: exitWith, exitFailure и прочими. Судя по всему, HUnit этого автоматически не делает, возвращая лишь статистику, которая игнорируется.exitFailure сама, если errors или failures в Counts больше нуля.
#include <string>
#include <cstdlib>
#include <iostream>
#include <algorithm>
int str_compare(std::string const & l, std::string const & r)
{
if (l == r)
return 0;
return l < r ? -1 : 1;
}
int str_compare(void const * l, void const * r) { return str_compare(*static_cast<std::string const *>(l), *static_cast<std::string const *>(r)); }
int main()
{
std::string strs[3] = { "foo", "bar", "baz" };
std::qsort(strs, 3, sizeof(std::string), str_compare); // В общем, работает, но UB
// std::sort(&strs[0], &strs[0] + 3); // вот так - лучше
for (auto & s : strs)
std::cout << s << std::endl;
return 0;
}import sublime
sublime.active_window().active_view().run_command('example')#include "stdafx.h"
#include <thread>
#include <vector>
#include <iostream>
void foo(std::size_t i)
{
// nothing to do
}
int main()
{
std::vector<std::thread> ths;
std::size_t n;
std::cin >> n;
for (std::size_t i = 0; i < n; ++i)
ths.push_back(std::thread(&foo, i));
for (auto & th : ths)
th.join();
return 0;
}Ret (Class::*)(Args...) [const]. Сам указатель получать &Class::Fun, а вызывать операторами .* или ->*std::function (boost::function), std::bind (boost::bind) или std::mem_fun, std::mem_fn для более унифицированного подхода:struct some
{
some() : value(0) {}
int inc() { return ++value; }
int dec() { return --value; }
int get() const { return value; }
int value;
};
int main()
{
some s;
int (some::*inc_f)() = &some::inc; // inc_f - указатель на функцию
std::cout << "(s.*inc_f)() = " << (s.*inc_f)() << std::endl; // оператор .* - оператор вызова по указателю на функцию
int (some::*val_ptr) = &some::value; // val_ptr - указатель на член
s.*val_ptr = 10;
std::cout << "s.*val_ptr = " << s.*val_ptr << std::endl;
int (some::*const_f)() const = &some::get; // const-функция
std::cout << "s.*const_f() = " << (s.*const_f)() << std::endl;
using namespace std::placeholders;
std::function<int (some&)> mem_f;
mem_f = std::bind(&some::inc, _1); // биндим на функцию-член, _1 - placeholder для объекта
std::cout << "mem_f(s) = " << mem_f(s) << std::endl; // s.inc();
mem_f = std::mem_fn(&some::dec); // другой способ через mem_fn
std::cout << "mem_f(s) = " << mem_f(s) << std::endl; // s.dec();
std::function<int()> mem_f_ = std::bind(&some::inc, &s); // биндим на функцию член и сразу указываем объект, получаем функцию без аргументов
std::cout << "mem_f_() = " << mem_f_() << std::endl; /// s.inc();
std::function<int(some const &)> const_fn = std::mem_fn(&some::get); // some const &
std::cout << "const_fn(s) = " << const_fn(s) << std::endl;
return 0;
}std::map<int, std::size_t>std::map<int, std::size_t> m;
for (int v : vals) { ++m[v]; }
std::vector<std::pair<int, std::size_t> > v(m.begin(), m.end());
std::sort(v.begin(), v.end(), [] (std::pair<int, std::size_t> const & l, std::pair<int, std::size_t> const & r) { return l.second > r.second; });
// в v пары "число - кол-во таких чисел", отсортированы по убыванию
// можно откинуть нижнюю часть (те, которые встречаются реже, чем какой-то процент, например, 10%)
v.erase(
std::find_if(v.begin(), v.end(), [] (std::pair<int, std::size_t> const & x) { return x.second < (v.size() / 10); }),
v.end());
// а сверху взять часто встречающиеся
int row_value = v.front().first;struct foo { foo(int const & x) : x_(x) {}; int const & x_; };
int bar() { return 42; }
void baz() { foo f(bar()); ... } // здесь в foo передается ссылка на временный объект, который умирает в конце выражения, однако ссылка сохраняется в объекте f.struct foo { foo(int & x) : x_(x) {}; int & x_; };
void foo()
{
std::shared_ptr<foo> f;
{
int x;
f.reset(new foo(x));
} // тут x помирает, ссылка на него невалидна
f->x_ = 10; // UB
}template <typename T> struct Vector { ... };
template <typename T> void foo(Vector<T> &); // definition in cpp
template struct Vector<Point2d>;
template struct Vector<Point3d>;
template void foo<Point2d>(Vector<Point2d> &);
template void foo<Point3d>(Vector<Point3d> &);Vector<Point2d> и Vector<Point3d> будут экпортированы.