第十三號艦隊

#include <stdio.h>
int main()
{
	char str[] = "Tom 42";
	int value;
	char name[30];
	sscanf(str, "%s %d", name, &value);
	printf("%s %d\n", name, value);
}

#include <sstream>
#include <iostream>
int main()
{
	std::string str = "Tom 42";
	int value;
	std::string name;
	std::stringstream ss;
	ss << str;
	ss >> name >> value;
	std::cout << name << " " << value << "\n";
}

sscanf(str, "%s: %d", name, &value);

int value;
std::string name, unused;
ss >> name >> unused >> value;

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
	char str[] = "Tom: 42", *p = strtok(str, ":");
	int value;
	char name[30];
	strcpy(name, p);
	p = strtok(NULL, ":");
	value = atoi(p);
	printf("%s %d\n", name, value);
}

#include <string>
#include <boost/spirit/include/qi.hpp>
namespace qi = boost::spirit::qi;
int main()
{
	std::string str = "Tom: 42";
	typedef std::string::const_iterator It;
	It iter = str.begin(), end = str.end();
	int value;
	std::string name;
	bool r = qi::phrase_parse(iter, end, 
		(*(qi::char_ - ':') >> ":" >> qi::int_), qi::ascii::blank, 
		name, value);

	if (r && iter == end) {
		std::cout << "Parsing succeeded\n";
		std::cout << name << " " << value << "\n";
	}
	else {
		std::cout << "Parsing failed\n";
		std::cout << "stopped at: \"" << std::string(iter, end) << "\"\n";
	}
}

bool r = qi::phrase_parse(iter, end, 
	(*(qi::char_ - ':') >> ":" >> qi::int_ >> "," >> qi::int_), qi::ascii::blank, 
	name, value, value1);

#include <string>
#include <boost/tuple/tuple.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/boost_tuple.hpp>
using MyTuple = boost::tuple<std::string, int, int>;
namespace qi = boost::spirit::qi;
template <typename Iterator, typename Skipper = qi::ascii::blank_type>
struct StringGrammar : qi::grammar <Iterator, MyTuple(), Skipper> {
	StringGrammar() : StringGrammar::base_type(parser, "StringParser Grammar") {
		name = *(qi::char_ - ':');
		value = qi::int_;

		parser = name >> ":" >> value >> "," >> value;
	}
private:
	qi::rule<Iterator, MyTuple(), Skipper> parser;
	// lexemes
	qi::rule<Iterator, std::string(), Skipper> name;
	qi::rule<Iterator, int(), Skipper> value;
};
int main()
{
	std::string str = "Tom: 42, 123";
	typedef std::string::const_iterator It;
	StringGrammar<It> grammer;
	It iter = str.begin(), end = str.end();
	MyTuple v;
	bool r = qi::phrase_parse(iter, end, 
		grammer, qi::ascii::blank,
		v);

	if (r && iter == end) {
		std::cout << "Parsing succeeded\n";
		std::cout << boost::get<0>(v) << " " << boost::get<1>(v) << " " << boost::get<2>(v) << "\n";
	}
	else {
		std::cout << "Parsing failed\n";
		std::cout << "stopped at: \"" << std::string(iter, end) << "\"\n";
	}
}

#include <iostream>
#include <string>
template <typename T>
void print(T obj)
{
        std::cout << obj.c_str() <<  ", length: " << obj.length() << "\n";
}
int main()
{
        print(std::string("123"));
        print(123);  // Compile error
}

#include <stdio.h>
#include <string>
template <class T>
concept bool Printable() {
    return requires(const T& obj) {
            { obj.c_str() }-> const char *;
            { obj.length() } -> size_t;
    };
}
void print(Printable obj)
{
        printf("%d: %s\n", obj.length(), obj.c_str());
}
int main()
{
        print(std::string("123"));
        print(123);
}

emplate <class T>
concept bool Printable() {
    return requires(const T& obj) {
            { obj.c_str() }-> const char *;
            { obj.length() } -> size_t;
    };
}
void print(Printable obj)
{
        if (!obj.empty()) {
                std::cout << obj.c_str() <<  ", length: " << obj.length() << "\n";
        }
}

int* produce();
void consume(int *);

char* produce();
void consume(char *);

enum errors
{
	SUCCESS = 0,
	NOTFOUND,
};
int openFile(const char *filename, int *pfd) {
	int fd = open(filename, , O_RDONLY);
	if (fd == -1) return NOTFOUND;
	*pfd = fd;
	return SUCCESS;
}

int openFile(const char *filename) {
	int fd = open(filename, , O_RDONLY);
	if (fd == -1) 
		throw std::exception("File not fould");
	return fd;
}

int openFile(const char *filename, std::error_code &ec) {
	int fd = open(filename, , O_RDONLY);
	if (fd == -1) 
		ec = std::error_code(errno, std::system_category());
	return fd;
}
std::error_code ec;
int fd = openFile(filePath, ec);
if (ec) {
	std::cout << "Category: " << ec.category().name()
			  << "Value: " << ec.value() << '\n'
	      << "Message: " << ec.message() << '\n';
}

int fd = openFile(filePath, ec);
if (ec) throw ec;

int fd = openFile(filePath, ec);
std::error_condition cond1(1, std::system_category());
std::error_condition cond2(2, std::system_category());
if (ec == cond1) {
}
else if (ec == cond2) {
}
else {
}

#include <iostream>
using namespace std;
#include <system_error>
#include <cassert>

namespace mylib
{
	namespace errc {

		enum my_error
		{
			failed = 0
		};

		inline const char* error_message(int c)
		{
			static const char* err_msg[] =
			{
				"Failed",
			};

			assert(c < sizeof(err_msg) / sizeof(err_msg[0]));
			return err_msg[c];
		}

		class my_error_category : public std::error_category
		{
		public:

			my_error_category()
			{ }

			std::string message(int c) const
			{
				return error_message(c);
			}

			const char* name() const noexcept { return "My Error Category"; }

			const static error_category& get()
			{
				const static my_error_category category_const;
				return category_const;
			}
		};

		inline std::error_code make_error_code(my_error e)
		{
			return std::error_code(static_cast<int>(e), my_error_category::get());
		}

	} // end namespace errc
} // end namespace mylib

namespace std {

	template<>
	struct is_error_code_enum<mylib::errc::my_error>
		: std::true_type
	{ };

} // end namespace std

int main()
{
	std::error_code ec1 = mylib::errc::make_error_code(mylib::errc::failed); // works
	std::error_code ec2 = mylib::errc::failed; // works
	bool result = (ec2 == mylib::errc::failed); // works

	std::cout << ec1 << std::endl;
}

typedef void(*callback)();
void testFunc(callback cb)
{
	cb();
}
testFunc([] {
	cout << "Lambda function" << endl;
});

typedef void(*callback)(void *);
void testFunc(callback cb, void *user_data)
{
	cb(user_data);
}
	int v = 123;
	testFunc([](void *user_data) {
		int *v = static_cast<int *>(user_data);
		cout << "Lambda function " << *v<< endl;
	}, &v);

// local variables
int x = 0;
float y = 1;

// locally defined uncopyable, unmovable type
struct MtEverest
{
	MtEverest() = default;
	MtEverest(const MtEverest& that) = delete; // no copy
	MtEverest(const MtEverest&& that) = delete; // no move
} mt_everest;

// create "user-data" payload  
auto payload = std::tie(x, y, mt_everest);
testFunc([](void *user_data) {
	auto& payload_tup = *reinterpret_cast<decltype(payload)*>(user_data);
	auto& xx = std::get<0>(payload_tup);
	auto& yy = std::get<1>(payload_tup);
	auto& me = std::get<2>(payload_tup);
}, &payload);

template <typename Lambda>
static auto lambdacb(Lambda &&l)
{
	thread_local auto* p = &l; // initial assignment, allows using auto
  p = &l;
	return []() { return (*p)(); };
}

typedef void(*callback)();
void testFunc(callback cb)
{
	cb();
}
// local variables
int x = 0;
float y = 1;

testFunc(lambdacb([&x, &y] {
	cout << x << " " << y << endl;
}));

int calc(const std::vector<int> &v)
{
	int count = 0;
	for (size_t i = 0; i < v.size() - 1; i++)
		if (v[i + 1] > v[i]) count++;
	return count;
}

template <typename T>
int calc(const T& v)
{
	int count = 0;
	for (auto it1 = v.cbegin(), it2 = v.cend(); it1 != v.cend(); it2 = it1, ++it1)
		if (it2 != v.end())
			if (*it1 > *it2) count++;
	return count;
}

template <typename T>
int calc(const T& v)
{
	using namespace ranges;
	auto larger = [](auto front, auto back) { return front > back; };
	return distance(v | view::adjacent_remove_if(larger)) - 1;
}

template <typename T>
int calc(const T& v)
{
        using namespace ranges;
        return count_if(v | view::sliding(2), [](const auto &v) {
                auto begin = ranges::begin(v);
                auto front = *begin++;
                auto back = *begin++;
                return front < back;
        });
}

#include <vector>
#include <memory>
using namespace std;

class Component
{
public:
    virtual ~Component() = default;
};

class Leaf : public Component
{
};

class Composite : public Component
{   
    vector<unique_ptr<Component>> children;
public:
    void add(Component *ele)
    {   
        children.push_back(std::unique_ptr<Component>(ele));
	}
};

class Component
{
public:
    virtual ~Component() = default;
    virtual Component* clone() = 0;
};

class Leaf : public Component
{
public:
    Component* clone() override { return new Leaf(); }
};

class Composite : public Component
{
    vector<unique_ptr<Component>> children;
public:
    void add(Component *ele)
    {
        children.push_back(std::unique_ptr<Component>(ele));
    }
    Component* clone() override {
        Composite* composite = new Composite();
        for (const auto &child : children)
                composite->children.push_back(
                        std::unique_ptr<Component>(child->clone()));
        return composite;
    }
};

class Leaf;
class Composite;
using CompositeVar = variant<Leaf, Composite>;
class Leaf final
{   
public:
    Leaf() = default;
    Leaf(const Leaf&) = default;
};

class Composite final
{   
    vector<CompositeVar> children;
public:
    Composite() = default;
    Composite(const Composite&) = default;
    void add(const CompositeVar &ele)
    {   
        children.push_back(ele);
    }
};