├── .gitignore ├── LICENSE ├── README.md ├── examples ├── README.md ├── SDL │ ├── ex1 │ │ ├── Makefile │ │ ├── README.md │ │ ├── cmd-switch.cpp │ │ ├── cmd-switch.hpp │ │ └── sdl-test.cpp │ └── ex2 │ │ ├── Makefile │ │ ├── README.md │ │ ├── cardback.bmp │ │ ├── cmd-switch.cpp │ │ ├── cmd-switch.hpp │ │ └── sdl-test.cpp ├── ScanLex │ ├── Makefile │ ├── backend_func.cpp │ ├── backend_func.hpp │ ├── backend_icode.cpp │ ├── backend_icode.hpp │ ├── code │ │ ├── add_two.mxvm │ │ ├── loop.mxvm │ │ ├── loop2.mxvm │ │ └── numbers.mxvm │ ├── main.cpp │ ├── parser.cpp │ ├── parser.hpp │ ├── parser_ast.cpp │ ├── parser_ast.hpp │ ├── parser_exception.cpp │ ├── parser_exception.hpp │ ├── scan_crunch.cpp │ ├── scan_crunch.hpp │ ├── scan_exception.cpp │ ├── scan_exception.hpp │ ├── scan_html.cpp │ ├── scan_html.hpp │ ├── scan_lex.cpp │ ├── scan_lex.hpp │ ├── scan_symbol.cpp │ ├── scan_symbol.hpp │ ├── scan_token.cpp │ ├── scan_token.hpp │ ├── script.txt │ └── test.txt ├── ac-tool │ ├── Makefile │ ├── Makefile.mingw │ ├── ac-tool.cpp │ ├── cmd-switch.cpp │ └── cmd-switch.hpp ├── acidcam_plugin │ ├── Makefile │ └── filter.cpp ├── bin_tree │ ├── Makefile │ ├── main.cpp │ └── tree.hpp ├── c-style │ ├── Makefile │ └── c-style.cpp ├── cmake │ ├── CMakeLists.txt │ └── test.cpp ├── cmd-switch │ ├── CMakeLists.txt │ ├── README.md │ └── source │ │ ├── cmd-switch.cpp │ │ ├── cmd-switch.hpp │ │ ├── print-lines-test.cpp │ │ └── switch-test.cpp ├── count_lines │ ├── Makefile │ ├── README.md │ ├── count_lines.cpp │ └── output.txt ├── cv-stereo-cam │ ├── Makefile │ └── main.cpp ├── cv_ex │ ├── Makefile │ └── main.cpp ├── diamond │ ├── Makefile │ ├── dmd.hpp │ └── main.cpp ├── expand_tabs │ ├── Makefile │ ├── cmd-switch.cpp │ ├── cmd-switch.hpp │ ├── index.txt │ └── main.cpp ├── expand_tabs_stdin │ ├── Makefile │ ├── cmd-switch.cpp │ ├── cmd-switch.hpp │ ├── index.txt │ └── main.cpp ├── filesystem │ ├── components │ │ ├── Makefile │ │ └── components.cpp │ ├── file_size │ │ ├── Makefile │ │ └── file_size.cpp │ ├── isdir │ │ ├── Makefile │ │ └── isdir.cpp │ ├── list_dir │ │ ├── Makefile │ │ └── list_dir.cpp │ └── replace_extension │ │ ├── Makefile │ │ └── ex.cpp ├── filter │ ├── Makefile │ ├── filter.cpp │ ├── filter.hpp │ └── main.cpp ├── filter_design │ ├── ac_filter.cpp │ ├── ac_filter.hpp │ ├── main.cpp │ ├── selfalpha.cpp │ └── selfalpha.hpp ├── filter_design_02 │ ├── Makefile │ ├── ac-filterlist.cpp │ ├── ac-filterlist.hpp │ └── main.cpp ├── fstream_binary_test │ ├── Makefile │ ├── README.md │ └── file.cpp ├── hash │ ├── Makefile │ ├── hash.cpp │ └── hash.hpp ├── img_convert │ ├── Makefile │ ├── README.md │ ├── cmd-switch.cpp │ ├── cmd-switch.hpp │ └── img_convert.cpp ├── inline_var_variadic_write │ ├── Makefile.clang │ ├── main.cpp │ └── rw.hpp ├── julia │ ├── Makefile │ ├── README.md │ └── julia.cpp ├── karma │ ├── Makefile │ └── karma.cpp ├── karma_trail │ ├── Makefile │ └── karma-trail.cpp ├── libacidcam │ ├── Makefile │ ├── cmd-switch.cpp │ ├── cmd-switch.hpp │ └── main.cpp ├── linescroll │ ├── Makefile │ └── linescroll.cpp ├── linked_list │ ├── Makefile.clang │ ├── Makefile.clang9 │ ├── linked.hpp │ └── main.cpp ├── list2cpp │ ├── Makefile │ ├── README.md │ ├── list2cpp.cpp │ ├── list2cpp.hpp │ ├── main.cpp │ └── progtest │ │ ├── Makefile │ │ ├── header.hpp │ │ ├── headerchar.hpp │ │ ├── headertest.cpp │ │ └── outputbytes.hpp ├── mandelbrot │ ├── Makefile │ ├── README.md │ ├── mandelbrot.cpp │ └── output.png ├── per_karma_trail │ ├── Makefile │ ├── README.txt │ ├── coma.txt │ ├── karma-trail.cpp │ └── per.hpp ├── per_temp │ ├── Makefile │ ├── main.cpp │ ├── per.cpp │ └── per.hpp ├── persist_map │ ├── Makefile.clang │ ├── Makefile.clang9 │ ├── permap.hpp │ ├── persist_concat.cpp │ ├── persist_map.cpp │ ├── persist_map_int.cpp │ ├── persist_string.cpp │ └── persist_struct.cpp ├── printlines │ ├── CMakeLists.txt │ └── printlines.cpp ├── printlines_stdin │ ├── CMakeLists.txt │ └── printlines.cpp ├── qt │ ├── main.cpp │ └── qt.pro ├── quine │ ├── Makefile │ └── quine.cpp ├── regex │ ├── Makefile │ └── r.cpp ├── remember_words_qt │ ├── README.md │ ├── main.cpp │ ├── main_window.cpp │ ├── main_window.h │ └── remember_words_qt.pro ├── replace │ ├── Makefile │ ├── cmd-switch.cpp │ ├── cmd-switch.hpp │ └── replace.cpp ├── set │ ├── Makefile │ └── set.cpp ├── shell_cmd │ ├── CMakeLists.txt │ ├── Makefile.cmd │ ├── README.md │ └── cmd.cpp ├── show_lines │ ├── Makefile │ └── show_lines.cpp ├── shuffle_list │ ├── Makefile │ ├── README.md │ └── shuffle_list.cpp ├── sort │ ├── Makefile │ └── sort.cpp ├── stack │ ├── Makefile │ ├── main.cpp │ └── stack.hpp ├── staticinitfree │ ├── Makefile │ ├── main.cpp │ └── staticif.hpp ├── stdin_to_bin │ ├── Makefile │ ├── cmd-switch.cpp │ ├── cmd-switch.hpp │ └── stdin_to_bin.cpp ├── stopwatch │ ├── Makefile │ ├── main.cpp │ └── stopwatch.hpp ├── strategy │ ├── Makefile │ ├── camera.cpp │ ├── camera.hpp │ ├── game.cpp │ ├── game.hpp │ ├── game_level.cpp │ ├── game_level.hpp │ ├── img │ │ ├── arial.ttf │ │ └── brick.bmp │ ├── level.cpp │ ├── level.hpp │ ├── main.cpp │ ├── window.cpp │ ├── window.hpp │ └── window_const.hpp ├── string_func │ ├── Makefile │ └── string.cpp ├── string_list │ ├── Makefile │ ├── list.hpp │ └── main.cpp ├── symbol_table │ ├── Makefile │ ├── main.cpp │ ├── table.hpp │ └── tree.hpp ├── tab_space_swap │ ├── Makefile │ ├── README.md │ └── tabs2space.cpp ├── transform │ ├── Makefile │ └── transform.cpp ├── tree │ ├── Makefile │ └── tree.cpp ├── ucase_stdin │ ├── Makefile │ └── stdin_stdout.cpp ├── url_download │ ├── Makefile.clang │ ├── README.md │ ├── download.cpp │ ├── socket.cpp │ └── socket.hpp ├── variant │ ├── Makefile │ └── var-ex.cpp └── word_count │ ├── Makefile │ ├── README.md │ └── word_count.cpp └── features ├── README.md ├── any ├── Makefile └── any.cpp ├── attributes ├── Makefile └── no-discard.cpp ├── auto ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── auto.cpp ├── decltype.cpp └── lambda.cpp ├── compile_time ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── arr_average.cpp ├── arr_sqrt.cpp ├── constexpr_if.cpp ├── constexpr_if2.cpp ├── constexpr_if3.cpp ├── even_odd.cpp ├── parse_int.cpp ├── prime_test.cpp └── primen.cpp ├── fold ├── Makefile └── fold.cpp ├── function ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── func_test.cpp └── functor.cpp ├── functional ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── function-ch.cpp ├── immutable.cpp └── pure-func.cpp ├── getter ├── Makefile └── getter.cpp ├── hexadecimal-float ├── Makefile ├── Makefile.clang ├── Makefile.clang9 └── hex_float.cpp ├── if_switch_variable_scope ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── program.cpp └── scope.cpp ├── inheritance ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── temp_inherit.cpp └── variadic_inherit.cpp ├── inline_variables ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── README.md ├── header_only.hpp ├── main.cpp ├── point.cpp └── point.hpp ├── invoke ├── Makefile ├── Makefile.clang ├── Makefile.clang9 └── invoke_test.cpp ├── move ├── Makefile └── move.cpp ├── nested_namespace_def ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── nested_namespace.cpp └── nested_namespace.hpp ├── optional ├── Makefile └── op.cpp ├── parallel ├── Makefile └── par.cpp ├── policy_and_traits ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── add_values.cpp ├── detecttype.cpp ├── error_int.cpp ├── hasdefault.cpp ├── isdefaulttype.cpp └── isoftype.cpp ├── polymorphism ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── dynamic-poly.cpp └── static-poly.cpp ├── string ├── Makefile └── string-test.cpp ├── string_view ├── Makefile └── sv.cpp ├── structured_bindings ├── Makefile ├── Makefile.clang ├── Makefile.clang9 └── sb.cpp ├── template ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── array_cast.cpp ├── databyte.cpp ├── erase_arr.cpp ├── for_each.cpp ├── multi_dim.cpp ├── specialize.cpp ├── template_stack.cpp └── variable_template.cpp ├── template_argument ├── Makefile ├── Makefile.clang └── args.cpp ├── template_auto ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── template_auto.cpp └── template_stack_auto.cpp ├── template_forward ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── template_enable_if.cpp └── template_forward.cpp ├── template_variadic ├── Makefile ├── Makefile.clang ├── Makefile.clang9 ├── template_stringcat.cpp ├── tup_test.cpp ├── variadic_base.cpp ├── variadic_construct.cpp ├── variadic_fold.cpp ├── variadic_forward.cpp ├── variadic_func.cpp ├── variadic_indices.cpp ├── variadic_nested.cpp ├── variadic_sizeof.cpp ├── variadic_strcat.cpp └── variadic_vec_fold.cpp └── variant ├── Makefile └── v.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | *DS_Store 2 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # cplusplus17.Examples 2 | 3 | This section serves as a repository where, over time, I'll be incorporating various examples to facilitate learning the latest features introduced in C++17. 4 | 5 | The initiative commenced in July 2017. 6 | 7 | For compilation, ensure that your compiler is compatible with C++17. On Linux/Mac, execute the following command within the directory containing the code: 8 | 9 | ```bash 10 | make 11 | ``` 12 | 13 | Additionally, this area includes a selection of miscellaneous example projects. 14 | -------------------------------------------------------------------------------- /examples/README.md: -------------------------------------------------------------------------------- 1 | 2 | This folder will contain complete program examples check features folder for C++17 language features 3 | 4 | -------------------------------------------------------------------------------- /examples/SDL/ex1/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=sdl-ex 3 | CFLAGS= -std=c++17 `pkg-config sdl2 --cflags` 4 | LDFLAGS= `pkg-config sdl2 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/SDL/ex1/README.md: -------------------------------------------------------------------------------- 1 | Program requires width/height arguments. 2 | 3 | ./sdl-ex --width=width --height=height 4 | 5 | will display random pixels 6 | 7 | 8 | -------------------------------------------------------------------------------- /examples/SDL/ex1/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/SDL/ex2/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=sdl-ex 3 | CFLAGS= -std=c++17 `pkg-config sdl2 --cflags` 4 | LDFLAGS= `pkg-config sdl2 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/SDL/ex2/README.md: -------------------------------------------------------------------------------- 1 | Program requires width/height arguments. 2 | 3 | ./sdl-ex --width=width --height=height 4 | 5 | will display random pixels 6 | 7 | 8 | -------------------------------------------------------------------------------- /examples/SDL/ex2/cardback.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus17.Examples/cb5cc03789da0d57e7b625ae1fd8a6981a1223df/examples/SDL/ex2/cardback.bmp -------------------------------------------------------------------------------- /examples/SDL/ex2/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/ScanLex/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS=-std=c++17 3 | LDFLAGS= 4 | CPP_FILES := $(wildcard *.cpp) 5 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 6 | OUTPUT_NAME=scanlex 7 | 8 | %.o: %.cpp 9 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 10 | 11 | all: $(OBJ_FILES) 12 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 13 | 14 | install: all 15 | cp $(OUTPUT_NAME) /usr/local/bin 16 | 17 | clean: 18 | rm -f $(OUTPUT_NAME) *.o -------------------------------------------------------------------------------- /examples/ScanLex/backend_func.cpp: -------------------------------------------------------------------------------- 1 | #include "backend_func.hpp" 2 | 3 | namespace backend { 4 | 5 | Function::Function(void (*f)(std::vector ¶m, scan::Variable &result)) : func{f} { 6 | 7 | } 8 | 9 | void Function::call(std::vector ¶m, scan::Variable &re) { 10 | if(func != nullptr) 11 | func(param, re); 12 | } 13 | 14 | void FunctionTable::add(const std::string &name, const Function &f) { 15 | func_table[name] = f; 16 | } 17 | 18 | bool FunctionTable::valid(const std::string &n) { 19 | if(func_table.find(n) != func_table.end()) 20 | return true; 21 | return false; 22 | } 23 | 24 | } -------------------------------------------------------------------------------- /examples/ScanLex/backend_func.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __BACKEND_H_FUNC_ 2 | #define __BACKEND_H_FUNC_ 3 | 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include"scan_symbol.hpp" 10 | 11 | namespace backend { 12 | 13 | 14 | class Function { 15 | public: 16 | Function() = default; 17 | Function(void (*f)(std::vector ¶m, scan::Variable &result)); 18 | void (*func)(std::vector ¶meters, scan::Variable &result) = nullptr; 19 | void call(std::vector ¶m, scan::Variable &result); 20 | }; 21 | 22 | class FunctionTable { 23 | public: 24 | std::unordered_map func_table; 25 | void add(const std::string &name, const Function &f); 26 | bool valid(const std::string &n); 27 | }; 28 | 29 | } 30 | 31 | #endif -------------------------------------------------------------------------------- /examples/ScanLex/code/add_two.mxvm: -------------------------------------------------------------------------------- 1 | 2 | proc main() 3 | begin 4 | echo("input value 1: "); 5 | let x = scan(); 6 | echo("input value 2: "); 7 | let y = scan(); 8 | echo(x, "+", y, "=", (x+y)); 9 | end; -------------------------------------------------------------------------------- /examples/ScanLex/code/loop.mxvm: -------------------------------------------------------------------------------- 1 | 2 | proc main() 3 | begin 4 | let x = 0; 5 | while(x < 10) { 6 | echo("Hello: ", x); 7 | x = x + 1; 8 | } 9 | end; -------------------------------------------------------------------------------- /examples/ScanLex/code/loop2.mxvm: -------------------------------------------------------------------------------- 1 | proc main() 2 | begin 3 | 4 | let i = 0; 5 | whie(i < 100) { 6 | let z = 0; 7 | while(z < 100) { 8 | z = z + 1; 9 | echo("i: ", i, " z: ", z); 10 | } 11 | i = i + 1; 12 | } 13 | 14 | end; 15 | -------------------------------------------------------------------------------- /examples/ScanLex/code/numbers.mxvm: -------------------------------------------------------------------------------- 1 | proc main() 2 | begin 3 | let x = 10; 4 | let y = 20; 5 | let z = x * y; 6 | let q = z * x + y; 7 | echo("value: ", q); 8 | end; 9 | -------------------------------------------------------------------------------- /examples/ScanLex/parser.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _PARSER_H__ 2 | #define _PARSER_H__ 3 | 4 | 5 | #include "scan_lex.hpp" 6 | #include "parser_exception.hpp" 7 | 8 | namespace parse { 9 | 10 | using namespace scan; 11 | 12 | class Parser { 13 | public: 14 | explicit Parser(Scanner *scanner); 15 | bool checkSyntax(); 16 | bool getToken(); 17 | bool match(TOKEN_TYPE type); 18 | bool match(KEYWORD_TYPES keyword); 19 | bool match(OP_TYPES op); 20 | 21 | protected: 22 | Scanner *scan; 23 | Token token; 24 | void parseProcedure(); 25 | void parseArglist(); 26 | void parseBody(); 27 | void parseStatement(); 28 | void parseExpr(); 29 | void parseTerm(); 30 | void parsePrim(); 31 | void parseCall(); 32 | void parseIf(); 33 | void parseWhile(); 34 | void parseFor(); 35 | void parseMatch(); 36 | void parseBlock(); 37 | void parseElif(); 38 | void parseArray(); 39 | void parseList(); 40 | void parseLet(); 41 | 42 | }; 43 | } 44 | 45 | #endif -------------------------------------------------------------------------------- /examples/ScanLex/parser_exception.cpp: -------------------------------------------------------------------------------- 1 | #include "parser_exception.hpp" 2 | 3 | 4 | namespace parse { 5 | ParserException::ParserException(const std::string &text) : etext{text} {} 6 | 7 | std::string ParserException::error() { 8 | return etext; 9 | } 10 | } -------------------------------------------------------------------------------- /examples/ScanLex/parser_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __PARSER_EXCEP_H__ 2 | #define __PARSER_EXCEP_H__ 3 | 4 | 5 | #include 6 | #include 7 | 8 | namespace parse { 9 | 10 | class ParserException { 11 | public: 12 | ParserException(const std::string &text); 13 | std::string error(); 14 | protected: 15 | std::string etext; 16 | }; 17 | 18 | } 19 | 20 | #endif -------------------------------------------------------------------------------- /examples/ScanLex/scan_crunch.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __SCAN_CRUNCH_H__ 2 | #define __SCAN_CRUNCH_H__ 3 | 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | namespace scan { 10 | class Scanner; 11 | void crunch(Scanner *scan, std::ostream &out); 12 | void uncrunch(std::istream &in); 13 | } 14 | 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /examples/ScanLex/scan_exception.cpp: -------------------------------------------------------------------------------- 1 | #include "scan_exception.hpp" 2 | 3 | namespace scan { 4 | ScanException::ScanException(const std::string &txt) : text {txt} {} 5 | std::string ScanException::error() { return text; } 6 | } -------------------------------------------------------------------------------- /examples/ScanLex/scan_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SCAN_EX_H_ 2 | #define _SCAN_EX_H_ 3 | 4 | #include 5 | 6 | namespace scan { 7 | class ScanException { 8 | public: 9 | ScanException(const std::string &txt); 10 | std::string error(); 11 | protected: 12 | std::string text; 13 | }; 14 | } 15 | 16 | 17 | #endif -------------------------------------------------------------------------------- /examples/ScanLex/scan_html.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __SCAN_H__HTML 2 | #define __SCAN_H__HTML 3 | 4 | #include 5 | #include 6 | 7 | namespace scan { 8 | void procHTML(std::istream &in, std::ostream &out); 9 | } 10 | 11 | #endif -------------------------------------------------------------------------------- /examples/ScanLex/scan_lex.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SCAN_LEX_H__ 2 | #define _SCAN_LEX_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include"scan_token.hpp" 10 | #include"scan_exception.hpp" 11 | #include"scan_symbol.hpp" 12 | #include"scan_crunch.hpp" 13 | 14 | namespace scan { 15 | 16 | class Scanner { 17 | public: 18 | explicit Scanner(const std::string &input_text); 19 | bool scan(); 20 | char getchar(); 21 | char peekchar(); 22 | char curchar(); 23 | char prevchar(); 24 | void print(); 25 | bool nextToken(Token &token); 26 | void reset(); 27 | void tokenIndex(int index, Token &token); 28 | void crunch(std::ostream &out); 29 | friend void crunch(Scanner *scan, std::ostream &out); 30 | protected: 31 | SymbolTable table; 32 | std::vector tokens; 33 | std::string text; 34 | int lineno; 35 | int colno; 36 | int index; 37 | char char_table[0xFF+1]; 38 | int token_index; 39 | void grabId(); 40 | void grabNumber(); 41 | void grabSymbol(); 42 | void grabString(); 43 | 44 | }; 45 | } 46 | 47 | #endif -------------------------------------------------------------------------------- /examples/ScanLex/script.txt: -------------------------------------------------------------------------------- 1 | 2 | 3 | proc test(x,y) 4 | begin 5 | x = 1; 6 | return (x + y); 7 | end; 8 | 9 | proc main(@args) 10 | begin 11 | y += test(10, test2(20)); 12 | x = x & y; 13 | end; 14 | -------------------------------------------------------------------------------- /examples/ScanLex/test.txt: -------------------------------------------------------------------------------- 1 | 2 | proc main() 3 | begin 4 | let s := "test one two three"; 5 | let x = 0; 6 | while(x < 10) { 7 | echo("Hello: ", x); 8 | x = x + 1; 9 | } 10 | end; -------------------------------------------------------------------------------- /examples/ac-tool/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | 3 | CFLAGS= -std=c++17 -O2 `pkg-config opencv4 acidcam --cflags` 4 | LDFLAGS= `pkg-config opencv4 acidcam --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | per.test: $(OBJ) 10 | $(CXX) -o ac-tool $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | install: 15 | cp ac-tool /usr/local/bin 16 | 17 | .PHONY: clean 18 | clean: 19 | rm -f ac-tool *.o 20 | -------------------------------------------------------------------------------- /examples/ac-tool/Makefile.mingw: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | CXX=x86_64-w64-mingw32-g++ 3 | MINGW_PATH=/usr/local/mingw64 4 | CFLAGS= -std=c++17 -I$(MINGW_PATH)/include -I$(MINGW_PATH)/include/acidcam 5 | LDFLAGS= $(MINGW_PATH)/lib/libacidcam.a $(MINGW_PATH)/lib/*opencv*a 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CFLAGS) $< -c -o $@ 9 | 10 | ac-tool: $(OBJ) 11 | $(CXX) -o ac-tool.exe $(OBJ) $(LDFLAGS) -static-libgcc -static-libstdc++ 12 | 13 | all: ac-tool 14 | 15 | .PHONY: clean 16 | clean: 17 | rm -f ac-tool.exe *.o 18 | -------------------------------------------------------------------------------- /examples/ac-tool/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/acidcam_plugin/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 `pkg-config opencv4 --cflags` 2 | LDFLAGS= `pkg-config opencv4 --libs` 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=filter.acidcam 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) -shared $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | clean: 14 | rm -f $(OUTPUT_NAME) *.o 15 | 16 | -------------------------------------------------------------------------------- /examples/acidcam_plugin/filter.cpp: -------------------------------------------------------------------------------- 1 | // simple filter plugin example 2 | #include 3 | #include 4 | 5 | extern "C" void filter(cv::Mat &frame) { 6 | static float alpha = 1.0; 7 | for(int z = 0; z < frame.rows; ++z) { 8 | for(int i = 0; i < frame.cols; ++z) { 9 | cv::Vec3b &pixel = frame.at(z, i); 10 | for(int q = 0; q < 3; ++q) { 11 | pixel[q] = static_cast(pixel[q] * alpha); 12 | 13 | } 14 | } 15 | } 16 | alpha += 0.01; 17 | if(alpha > 4.0) 18 | alpha = 1.0; 19 | } 20 | -------------------------------------------------------------------------------- /examples/bin_tree/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=bin_tree-test 6 | 7 | %.o: %.cpp tree.hpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/bin_tree/main.cpp: -------------------------------------------------------------------------------- 1 | #include"tree.hpp" 2 | #include 3 | #include 4 | 5 | int main() { 6 | try { 7 | tree::Tree values; 8 | std::cout << "Enter Key/Value loop, type quit for key to break loop...\n"; 9 | while(1) { 10 | std::string keyval, value; 11 | std::cout << "Enter key: "; 12 | std::getline(std::cin, keyval); 13 | if(keyval == "quit") break; 14 | std::cout << "Enter value: "; 15 | std::getline(std::cin, value); 16 | values.addItem(keyval,value); 17 | std::cout << "All keys: \n"; 18 | values.printValues(); 19 | } 20 | } catch(tree::KeyNotFound) { 21 | std::cerr << "Error key not found, add first..\n"; 22 | } 23 | return 0; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /examples/c-style/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=c-style 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/c-style/c-style.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | if(argc != 2) { 6 | fprintf(stderr, "Error incorrect arguments..\n"); 7 | return EXIT_FAILURE; 8 | } 9 | FILE *fptr = fopen(argv[1], "r"); 10 | if(!fptr) { 11 | fprintf(stderr, "Error could not open %s\n", argv[1]); 12 | return EXIT_FAILURE; 13 | } 14 | unsigned int index = 1; 15 | printf("%d: ", index); 16 | while(!feof(fptr)) { 17 | char c = fgetc(fptr); 18 | if(c != EOF) { 19 | if(c == '\n') { 20 | index ++; 21 | printf("\n%d: ", index); 22 | } else { 23 | printf("%c", c); 24 | } 25 | } 26 | } 27 | printf("\n"); 28 | fclose(fptr); 29 | return EXIT_SUCCESS; 30 | } 31 | -------------------------------------------------------------------------------- /examples/cmake/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.5 FATAL_ERROR) 2 | 3 | project(test01 LANGUAGES CXX) 4 | set(CMAKE_CXX_STANDARD 17) 5 | set(CMAKE_CXX_STANDARD_REQURIED ON) 6 | set(CMAKE_CXX_EXTENSIONS OFF) 7 | 8 | add_executable(cmake-test test.cpp) 9 | -------------------------------------------------------------------------------- /examples/cmake/test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | std::cout << "Hello World, C++17 CMake!\n"; 6 | exit(EXIT_SUCCESS); 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /examples/cmd-switch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.5 FATAL_ERROR) 2 | project(cmd-switch LANGUAGES CXX) 3 | 4 | if(NOT CMAKE_BUILD_TYPE) 5 | set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE) 6 | endif() 7 | 8 | message(STATUS "Build configuration is: ${CMAKE_BUILD_TYPE}") 9 | message(STATUS "is the C++ compiler loaded? ${CMAKE_CXX_COMPILER_LOADED}") 10 | 11 | if(CMAKE_CXX_COMPILER_LOADED) 12 | message(STATUS "The C++ Compiler ID is: ${CMAKE_CXX_COMPILER_ID}") 13 | message(STATUS "The C++ Compiler Version: ${CMAKE_CXX_COMPILER_VERSION}") 14 | endif() 15 | 16 | set(CMAKE_CXX_STANDARD 17) 17 | set(CMAKE_CXX_STANDARD_REQURIED ON) 18 | set(CMAKE_CXX_EXTENSIONS OFF) 19 | 20 | if(CMAKE_BUILD_TYPE STREQUAL "Release") 21 | list(APPEND COMPILER_FLAGS "-Wall" "-pedantic" "-ansi" "-Ofast") 22 | else() 23 | message(STATUS "Debug Mode") 24 | list(APPEND COMPILER_FLAGS "-Wall" "-pedantic" "-ansi") 25 | endif() 26 | 27 | list(APPEND source_files 28 | ${CMAKE_SOURCE_DIR}/source/cmd-switch.cpp 29 | ) 30 | 31 | list(APPEND install_headers ${CMAKE_SOURCE_DIR}/source/cmd-switch.hpp) 32 | add_library(cmd-switch ${source_files}) 33 | add_executable(cmd-switch-test ${CMAKE_SOURCE_DIR}/source/switch-test.cpp) 34 | target_link_libraries(cmd-switch-test cmd-switch) 35 | add_executable(print-lines-test ${CMAKE_SOURCE_DIR}/source/print-lines-test.cpp) 36 | target_link_libraries(print-lines-test cmd-switch) 37 | install(TARGETS cmd-switch DESTINATION lib) 38 | install(FILES ${install-headers} DESTINATION include/cmd-switch) 39 | 40 | -------------------------------------------------------------------------------- /examples/cmd-switch/README.md: -------------------------------------------------------------------------------- 1 | Simple Argument Extract Static Library 2 | C++17 Example 3 | 4 | written by Jared Bruni 5 | 6 | to build 7 | 8 | enter this directory 9 | 10 | $ mkdir build 11 | 12 | $ cd build 13 | 14 | $ cmake .. 15 | 16 | $ make -j4 17 | 18 | 19 | -------------------------------------------------------------------------------- /examples/cmd-switch/source/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/cmd-switch/source/print-lines-test.cpp: -------------------------------------------------------------------------------- 1 | // use form argument=value 2 | // so switch 3 | // --file="filename.txt" 4 | // --sep="seperator string" 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include"cmd-switch.hpp" 10 | 11 | int main(int argc, char **argv) { 12 | try { 13 | cmd::ArgumentList argz(argc, argv); 14 | std::string filename; 15 | argz.require("--file", filename, "Input filename"); 16 | std::string sep_str; 17 | bool line_sep=argz.extract("--sep", sep_str); 18 | std::fstream file; 19 | file.open(filename, std::ios::in); 20 | if(!file.is_open()) { 21 | std::cerr << "Error could not open file: "<< argv[1] << "\n"; 22 | exit(EXIT_FAILURE); 23 | } 24 | unsigned int index = 1; 25 | std::string sep = sep_str+" "; 26 | if(line_sep == false) 27 | sep = " "; 28 | 29 | while(!file.eof()) { 30 | std::string line; 31 | std::getline(file, line); 32 | if(file) 33 | std::cout << index++ << sep << line << "\n"; 34 | } 35 | file.close(); 36 | exit(EXIT_SUCCESS); 37 | } 38 | catch(cmd::ArgExcep &e) { 39 | std::cerr << e.what() << "\n"; 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /examples/cmd-switch/source/switch-test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include"cmd-switch.hpp" 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | try { 7 | cmd::ArgumentList argz(argc, argv); 8 | if(argz.check("--init") == true) { 9 | std::cout << "init flag present..\n"; 10 | } 11 | std::string pass; 12 | if(argz.check("--pass") == true && argz.require("--password", pass, "Input password") == true) { 13 | std::cout << "Password: " << pass << "\n"; 14 | } 15 | std::string value; 16 | if(argz.extract("--value", value) == true) { 17 | std::cout << "value flag extracted: " << value << "\n"; 18 | } 19 | //if(argz.check_require("--test") == true) { 20 | // std::cout << "required test" << "\n"; 21 | //} 22 | argz.print(); 23 | std::vector lst {"--value"}; 24 | cmd::ArgumentStringList alst(argc, argv); 25 | if(Argument_FindInList(lst, alst)) { 26 | std::cout << "Value found..\n"; 27 | } 28 | 29 | } catch(cmd::ArgExcep &e) { 30 | std::cerr << e.what() << "\n"; 31 | exit(EXIT_FAILURE); 32 | } 33 | std::cout << "Success..\n"; 34 | exit(EXIT_SUCCESS); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /examples/count_lines/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=count_lines 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/count_lines/README.md: -------------------------------------------------------------------------------- 1 | 2 | Check output.txt in this folder for example output of the program. 3 | -------------------------------------------------------------------------------- /examples/cv-stereo-cam/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=cv-stereo-cam 3 | CFLAGS= -std=c++17 `pkg-config opencv4 --cflags` 4 | LDFLAGS=`pkg-config opencv4 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/cv_ex/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=cv_example 3 | CFLAGS= -std=c++17 `pkg-config opencv4 --cflags` 4 | LDFLAGS=`pkg-config opencv4 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/cv_ex/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(int argc, char **argv) { 4 | 5 | if(argc != 2) { 6 | std::cerr << "Error requires one argument capture device index..\n"; 7 | exit(EXIT_FAILURE); 8 | return 0; 9 | } 10 | 11 | cv::VideoCapture cap(atoi(argv[1])); 12 | if(!cap.isOpened()) { 13 | std::cerr << "Could not open capture device..\n"; 14 | exit(EXIT_FAILURE); 15 | } 16 | bool active = true; 17 | cv::namedWindow("cv"); 18 | while(active) { 19 | cv::Mat m; 20 | if(cap.read(m)) { 21 | cv::imshow("cv", m); 22 | if(cv::waitKey(10) == 27) 23 | exit(EXIT_SUCCESS); 24 | } 25 | } 26 | return EXIT_SUCCESS; 27 | } 28 | -------------------------------------------------------------------------------- /examples/diamond/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=dmd-example 3 | CFLAGS= -std=c++17 -O2 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/diamond/main.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "dmd.hpp" 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | Diamond dmd(argc, argv); 7 | std::string line; 8 | while(dmd.next(line)) { 9 | std::cout << line << "\n"; 10 | } 11 | dmd.reset(); 12 | while(dmd.next(line)) { 13 | std::cout << dmd.filename() << ":" << line << "\n"; 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /examples/expand_tabs/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=expand-tabs 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/expand_tabs/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /examples/expand_tabs/index.txt: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /examples/expand_tabs/main.cpp: -------------------------------------------------------------------------------- 1 | // Arguments take the form of 2 | // --switch=value 3 | // --file=input-filename 4 | // --num=number of spaces 5 | 6 | #include 7 | #include 8 | #include"cmd-switch.hpp" 9 | 10 | int main(int argc, char **argv) { 11 | try { 12 | cmd::ArgumentList argz(argc, argv); 13 | std::string filename; 14 | argz.require("--file", filename, "input filename"); 15 | std::string num; 16 | argz.require("--num", num, "number of spaces"); 17 | 18 | int num_spaces = atoi(num.c_str()); 19 | if(num_spaces <= 0) { 20 | std::cerr << "Requires Greater than Zero value for spaces.\n"; 21 | exit(EXIT_FAILURE); 22 | } 23 | 24 | std::fstream file; 25 | file.open(filename, std::ios::in); 26 | if(!file.is_open()) { 27 | std::cerr << "Error could not open file: " << filename << "\n"; 28 | exit(EXIT_FAILURE); 29 | } 30 | while(!file.eof()) { 31 | char c = file.get(); 32 | if(c == '\t') { 33 | for(int i = 0; i < num_spaces; ++i) { 34 | std::cout << " "; 35 | } 36 | } else { 37 | std::cout << c; 38 | } 39 | } 40 | file.close(); 41 | } catch(cmd::ArgExcep &e) { 42 | std::cerr << e.what() << "\n"; 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /examples/expand_tabs_stdin/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=expand-tabs 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/expand_tabs_stdin/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /examples/expand_tabs_stdin/index.txt: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /examples/expand_tabs_stdin/main.cpp: -------------------------------------------------------------------------------- 1 | // Arguments take the form of 2 | // --switch=value 3 | // --file=input-filename 4 | // --num=number of spaces 5 | 6 | #include 7 | #include 8 | #include"cmd-switch.hpp" 9 | 10 | int main(int argc, char **argv) { 11 | try { 12 | cmd::ArgumentList argz(argc, argv); 13 | std::string num; 14 | argz.require("--num", num, "number of spaces"); 15 | 16 | int num_spaces = atoi(num.c_str()); 17 | if(num_spaces <= 0) { 18 | std::cerr << "Requires Greater than Zero value for spaces.\n"; 19 | exit(EXIT_FAILURE); 20 | } 21 | std::istream &file = std::cin; 22 | while(!file.eof()) { 23 | char c = file.get(); 24 | if(c == '\t') { 25 | for(int i = 0; i < num_spaces; ++i) { 26 | std::cout << " "; 27 | } 28 | } else { 29 | std::cout << c; 30 | } 31 | } 32 | } catch(cmd::ArgExcep &e) { 33 | std::cerr << e.what() << "\n"; 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /examples/filesystem/components/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=components 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/filesystem/components/components.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main(int argc, char **argv) { 7 | if(argc == 1) { 8 | std::cerr << "Error requires one argument filename..\n"; 9 | exit(EXIT_SUCCESS); 10 | } 11 | std::filesystem::path file_path{argv[1]}; 12 | std::cout << "path components: \n"; 13 | for(auto &i : file_path) { 14 | std::cout << i.string() << "\n"; 15 | } 16 | // or 17 | for(auto p = file_path.begin(); p != file_path.end(); ++p) { 18 | std::cout << p->string() << "\n"; 19 | } 20 | 21 | file_path.append("New_Dir"); 22 | file_path.concat("1"); 23 | std::cout << file_path.string() << "\n"; 24 | 25 | return EXIT_SUCCESS; 26 | } 27 | -------------------------------------------------------------------------------- /examples/filesystem/file_size/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=file_size 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/filesystem/file_size/file_size.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | 7 | if(argc == 1) { 8 | std::cerr << "Use " << argv[0] << " file\n to print file size\n"; 9 | return 0; 10 | } 11 | 12 | std::filesystem::path file_path{argv[1]}; 13 | if(!is_directory(file_path) && exists(file_path)) { 14 | std::cout << "file: " << file_path.string() << " is " << file_size(file_path) << " bytes.\n"; 15 | } else { 16 | std::cerr << "invalid input..\n"; 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /examples/filesystem/isdir/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=isdir 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/filesystem/isdir/isdir.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | if(argc == 1) { 6 | std::cerr << "Error use " << argv[0] << " path.\n"; 7 | return 1; 8 | } 9 | std::filesystem::path file_path{argv[1]}; 10 | if(is_directory(file_path)) { 11 | std::cout << file_path.string() << " is a directory.\n"; 12 | } else { 13 | std::cout << file_path.string() << " is not a directory.\n"; 14 | } 15 | return 0; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /examples/filesystem/list_dir/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=list_dir 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/filesystem/list_dir/list_dir.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | if(argc == 1) { 7 | std::cerr << argv[0] << " directory \n"; 8 | std::cerr << argv[0] << " directory -r (recursive)\n"; 9 | return 0; 10 | } 11 | if(argc == 3 && std::string(argv[2]) == "-r") { 12 | std::filesystem::path p{argv[1]}; 13 | if(is_directory(p)) { 14 | for(auto &i : std::filesystem::recursive_directory_iterator(argv[1])) { 15 | std::cout << i.path().string() << "\n"; 16 | } 17 | } else { 18 | std::cerr << "invalid input..\n"; 19 | } 20 | } 21 | if(argc == 2) { 22 | std::filesystem::path p{argv[1]}; 23 | if(is_directory(p)) { 24 | for(auto &i : std::filesystem::directory_iterator(argv[1])) { 25 | std::cout << i.path().string() << "\n"; 26 | } 27 | } else { 28 | std::cerr << "invalid input..\n"; 29 | } 30 | } 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /examples/filesystem/replace_extension/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=extract-f 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/filesystem/replace_extension/ex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | std::string build_filename(const std::string &filename, const std::string &output_path,const std::string &ext) { 7 | std::filesystem::path p{filename}; 8 | p.replace_extension(ext); 9 | std::filesystem::path output_p{output_path}; 10 | output_p.append(p.filename().string()); 11 | return output_p.string(); 12 | } 13 | 14 | int main(int argc, char **argv) { 15 | if(argc == 1) { 16 | std::cerr << "Error use " << argv[0] << " filename path extension.\n"; 17 | return EXIT_SUCCESS; 18 | } 19 | if(argc == 4) { 20 | std::cout << "final path: " << build_filename(argv[1], argv[2], argv[3]) << "\n"; 21 | } else { 22 | std::cerr << "invalid arguments..\n"; 23 | return EXIT_FAILURE; 24 | } 25 | 26 | return EXIT_SUCCESS; 27 | } 28 | -------------------------------------------------------------------------------- /examples/filter/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=filter 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/filter/filter.cpp: -------------------------------------------------------------------------------- 1 | #include "filter.hpp" 2 | 3 | namespace ac { 4 | 5 | // initalize 6 | FilterObject::FilterObject() : alpha(0) { 7 | } 8 | 9 | FilterObject::FilterObject(const std::string &s) : alpha(0), id(s) { 10 | } 11 | 12 | FilterObject::FilterObject(const FilterObject &fo) { 13 | this->operator=(fo); 14 | } 15 | 16 | FilterObject &FilterObject::operator=(const FilterObject &fo) { 17 | // copy data 18 | // collection = fo.collection 19 | id = fo.id; 20 | alpha = fo.alpha; 21 | return *this; 22 | } 23 | 24 | void FilterObject::setID(const std::string &s) { 25 | id = s; 26 | } 27 | 28 | SelfAlphaBlend::SelfAlphaBlend() : FilterObject("SelfAlphaBlend") { 29 | reset(); 30 | } 31 | 32 | void SelfAlphaBlend::operator()(/*cv::Mat &frame*/) { 33 | // modify frame 34 | alpha = 1.0; 35 | std::cout << "SelfAlphaBlend ...\n"; 36 | } 37 | 38 | void SelfAlphaBlend::reset() { 39 | alpha = 0; 40 | std::cout << "Filter " << id << " reset.\n"; 41 | } 42 | 43 | SelfScale::SelfScale() : FilterObject("SelfScale") { 44 | reset(); 45 | } 46 | 47 | void SelfScale::operator()(/*cv::Mat &frame */) { 48 | std::cout << "in SelfScale ... \n"; 49 | alpha = 1; 50 | } 51 | 52 | void SelfScale::reset() { 53 | alpha = 0; 54 | std::cout << "Filter " << id << " reset.\n"; 55 | } 56 | 57 | } 58 | -------------------------------------------------------------------------------- /examples/filter/filter.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __FILTER_TEST__H__ 3 | #define __FILTER_TEST__H__ 4 | 5 | #include 6 | #include 7 | 8 | namespace ac { 9 | 10 | class FilterObject { 11 | public: 12 | FilterObject(); 13 | FilterObject(const std::string &s); 14 | FilterObject(const FilterObject &fo); 15 | FilterObject &operator=(const FilterObject &fo); 16 | virtual ~FilterObject() {} 17 | void setID(const std::string &s); 18 | virtual void operator()(/*cv::Mat &frame*/) = 0; 19 | virtual void reset() = 0; 20 | protected: 21 | double alpha; 22 | std::string id; 23 | //MatrixCollection 24 | //cv::Mat 25 | private: 26 | }; 27 | 28 | class SelfAlphaBlend : public FilterObject { 29 | public: 30 | SelfAlphaBlend(); 31 | void operator()() override; 32 | void reset() override; 33 | }; 34 | 35 | class SelfScale : public FilterObject { 36 | public: 37 | SelfScale(); 38 | void operator()(/*cv::Mat &frame*/) override; 39 | void reset() override; 40 | }; 41 | } 42 | 43 | #endif 44 | 45 | -------------------------------------------------------------------------------- /examples/filter/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include"filter.hpp" 5 | 6 | 7 | 8 | void procFilter(ac::FilterObject *obj) { 9 | (*obj)(/*mat*/); 10 | } 11 | 12 | int main() { 13 | std::vector filter_stack; 14 | // Create new filter 15 | ac::SelfAlphaBlend blend; 16 | filter_stack.push_back(&blend); 17 | ac::SelfScale scale; 18 | filter_stack.push_back(&scale); 19 | for(unsigned int i = 0; i < filter_stack.size(); ++i) { 20 | procFilter(filter_stack[i]); 21 | } 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /examples/filter_design/ac_filter.cpp: -------------------------------------------------------------------------------- 1 | #include "ac_filter.hpp" 2 | 3 | namespace ac { 4 | 5 | unsigned char wrap_cast(double d) { 6 | unsigned long val = static_cast(d); 7 | if(val > 255) 8 | val = val%255; 9 | return static_cast(val); 10 | } 11 | 12 | 13 | AC_Filter::AC_Filter(const std::string &n) : name{n} { 14 | filters.push_back(this); 15 | map_filter[n] = this; 16 | } 17 | 18 | void AC_Filter::exec(cv::Mat &frame) { 19 | // args.collection.shiftFrames(frame); 20 | proc(frame, args); 21 | } 22 | 23 | std::string AC_Filter::get_name() const { 24 | return name; 25 | } 26 | 27 | void AC_Filter::setalpha(double d) { 28 | args.alpha = d; 29 | } 30 | 31 | void AC_Filter::Args::move_in_out() { 32 | if(dir == true) { 33 | alpha += 0.01; 34 | if(alpha >= 5.0) 35 | dir = false; 36 | } else { 37 | alpha -= 0.01; 38 | if(alpha <= 1.0) 39 | dir = true; 40 | } 41 | } 42 | 43 | AC_Filter::Args AC_Filter::args; 44 | std::vector filters; 45 | std::unordered_map map_filter; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /examples/filter_design/ac_filter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _AC_FILTER_H__ 2 | #define _AC_FILTER_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | namespace ac { 11 | 12 | 13 | unsigned char wrap_cast(double d); 14 | 15 | class AC_Filter { 16 | public: 17 | AC_Filter(const std::string &name); 18 | virtual ~AC_Filter() = default; 19 | void exec(cv::Mat &frame); 20 | std::string get_name() const; 21 | void setalpha(double d); 22 | protected: 23 | struct Args { 24 | //MatrixCollection<32> collection; 25 | double alpha = 1.0; 26 | bool dir = true; 27 | void move_in_out(); 28 | }; 29 | std::string name; 30 | static Args args; 31 | virtual void proc(cv::Mat &frame, Args &args) = 0; 32 | }; 33 | 34 | extern std::vector filters; 35 | extern std::unordered_map map_filter; 36 | } 37 | #endif 38 | 39 | 40 | -------------------------------------------------------------------------------- /examples/filter_design/main.cpp: -------------------------------------------------------------------------------- 1 | #include"ac_filter.hpp" 2 | #include"selfalpha.hpp" 3 | #include 4 | 5 | ac::SelfAlpha alpha; 6 | 7 | int main(int argc, char **argv) { 8 | if(argc <= 3) { 9 | for(size_t i = 0; i < ac::filters.size(); ++i) { 10 | std::cout << i << ": " << ac::filters[i]->get_name() << "\n"; 11 | } 12 | exit(0); 13 | } 14 | else if(argc == 4){ 15 | cv::Mat img = cv::imread(argv[1]); 16 | if(img.empty()) { 17 | std::cerr << "Error loading: " << argv[1] << "\n"; 18 | exit(EXIT_FAILURE); 19 | } 20 | size_t index = atoi(argv[2]); 21 | double d = atof(argv[3]); 22 | if(index >= 0 && index < ac::filters.size()) { 23 | ac::filters[index]->setalpha(d); 24 | ac::filters[index]->exec(img); 25 | } else { 26 | std::cerr << "Error invalid index...\n"; 27 | exit(EXIT_FAILURE); 28 | } 29 | cv::imwrite("output.png", img); 30 | std::cout << "wrote: output.png\n"; 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /examples/filter_design/selfalpha.cpp: -------------------------------------------------------------------------------- 1 | #include"selfalpha.hpp" 2 | 3 | namespace ac { 4 | 5 | SelfAlpha::SelfAlpha() : AC_Filter("SelfAlpha") {} 6 | 7 | void SelfAlpha::proc(cv::Mat &frame, Args &args) { 8 | for(int z = 0; z < frame.rows; ++z) { 9 | for(int i = 0; i < frame.cols; ++i) { 10 | 11 | cv::Vec3b &pixel = frame.at(z, i); 12 | for(int j = 0; j < 3; ++j) 13 | pixel[j] = wrap_cast(pixel[j] * args.alpha); 14 | 15 | } 16 | } 17 | args.move_in_out(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /examples/filter_design/selfalpha.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _SELF_ALPHA_H_ 2 | #define _SELF_ALPHA_H_ 3 | 4 | #include"ac_filter.hpp" 5 | 6 | namespace ac { 7 | 8 | class SelfAlpha : public AC_Filter { 9 | public: 10 | SelfAlpha(); 11 | protected: 12 | void proc(cv::Mat &frame, Args &args) override; 13 | 14 | }; 15 | 16 | } 17 | 18 | #endif 19 | 20 | -------------------------------------------------------------------------------- /examples/filter_design_02/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=ftest-ex 3 | CFLAGS= -std=c++17 -O2 -I. `pkg-config acidcam opencv4 --cflags` 4 | LDFLAGS= `pkg-config acidcam opencv4 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/filter_design_02/ac-filterlist.cpp: -------------------------------------------------------------------------------- 1 | #include "ac-filterlist.hpp" 2 | 3 | namespace ac { 4 | 5 | FilterList::~FilterList() { 6 | 7 | } 8 | 9 | 10 | FilterList::FilterList(FilterList &&l) : objects{std::move(l.objects)} { 11 | 12 | } 13 | 14 | 15 | FilterList &FilterList::operator=(FilterList &&l) { 16 | objects = std::move(l.objects); 17 | return *this; 18 | } 19 | 20 | 21 | void FilterList::add(FilterObj *obj) { 22 | objects.push_back(std::unique_ptr(obj)); 23 | } 24 | 25 | void FilterList::exec(cv::Mat &frame) { 26 | for(auto &i : objects) 27 | i->update(frame); 28 | } 29 | 30 | void FilterList::call(int n, cv::Mat &frame) { 31 | if(n >= 0 && n < objects.size()) 32 | objects[n]->update(frame); 33 | } 34 | 35 | 36 | void FilterList::clear() { 37 | if(!objects.empty()) 38 | objects.erase(objects.begin(), objects.end()); 39 | } 40 | 41 | void FilterList::rmv(int n) { 42 | if(n >= 0 && n < objects.size()) 43 | objects.erase(objects.begin()+n); 44 | } 45 | 46 | 47 | void FilterList::pop() { 48 | objects.pop_back(); 49 | } 50 | 51 | 52 | } 53 | -------------------------------------------------------------------------------- /examples/filter_design_02/ac-filterlist.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __FILTER_OBJ__H__ 2 | #define __FILTER_OBJ__H__ 3 | 4 | #include "ac.h" 5 | #include 6 | #include 7 | #include 8 | 9 | namespace ac { 10 | 11 | 12 | class FilterObj { 13 | public: 14 | virtual ~FilterObj() = default; 15 | virtual void init() = 0; 16 | virtual void update(cv::Mat &frame) = 0; 17 | virtual void cleanup() = 0; 18 | }; 19 | 20 | 21 | class FilterList { 22 | public: 23 | FilterList() = default; 24 | FilterList(const FilterList &l) = delete; 25 | FilterList(FilterList &&l); 26 | 27 | FilterList &operator=(const FilterList &l) = delete; 28 | FilterList &operator=(FilterList &&l); 29 | ~FilterList(); 30 | void add(FilterObj *obj); 31 | void clear(); 32 | void pop(); 33 | void rmv(int n); 34 | void exec(cv::Mat &frame); 35 | void call(int n, cv::Mat &frame); 36 | private: 37 | std::deque> objects; 38 | }; 39 | 40 | } 41 | 42 | #endif 43 | 44 | -------------------------------------------------------------------------------- /examples/fstream_binary_test/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=binary-test 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/fstream_binary_test/README.md: -------------------------------------------------------------------------------- 1 | # fstream binary file test 2 | 3 | This is a small example that read/writes a struct to a file 4 | 5 | $ ./binary-test filename.dat write 6 | 7 | will prompt for contents of file then write to disk 8 | 9 | $ ./binary-test filename.dat read 10 | 11 | will print out the values stored in filename.dat 12 | 13 | 14 | -------------------------------------------------------------------------------- /examples/hash/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=hash-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/hash/hash.cpp: -------------------------------------------------------------------------------- 1 | // Just practicing some different ideas and concepts 2 | // chained hash table 3 | // mixing different stuff 4 | // in reality it would be better to use 5 | // a map or unordered map but this is to practice 6 | // writing my own chained hash table 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #include "hash.hpp" 13 | 14 | 15 | int main(int argc, char **argv) { 16 | htable::Table table; 17 | while(1) { 18 | std::string key; 19 | std::string value; 20 | std::cout << "enter key: "; 21 | std::getline(std::cin, key); 22 | std::cout << "enter value: "; 23 | std::getline(std::cin, value); 24 | table[key] = value; 25 | // print table 26 | std::cout << "*****\tprint table\n"; 27 | for(unsigned int i = 0; i < table.size(); ++i) { 28 | if(table.at(i).size() > 0) { 29 | for(auto & [first, second] : table.at(i)) { 30 | std::cout << "hash:" << i << " -> " << first << ":" << second << "\n"; 31 | } 32 | } 33 | } 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /examples/img_convert/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=img_convert 3 | CFLAGS= -std=c++17 `pkg-config opencv4 --cflags` 4 | LDFLAGS=`pkg-config opencv4 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/img_convert/README.md: -------------------------------------------------------------------------------- 1 | Wrote this to help out with conversions of multiple files to make it easier on me 2 | 3 | Output file list with 4 | 5 | $ ls | grep file_type > list.txt 6 | 7 | or 8 | 9 | $ ls | grep png > list.txt 10 | 11 | then use program to batch convert and resize 12 | 13 | $ img_convert --input=list.txt --output=jpg --res=1280x720 14 | 15 | will stretch the resolution so be aware of that 16 | 17 | or don't change the res 18 | 19 | $ img_convert --input=list.txt --output=png 20 | 21 | or output to certain path 22 | 23 | $ img_convert --input=list.txt --output=jpg --path=/Users/jared 24 | 25 | -------------------------------------------------------------------------------- /examples/img_convert/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/inline_var_variadic_write/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXXFLAGS=-std=c++17 3 | LDFLAGS= 4 | CPP_FILES := $(wildcard *.cpp) 5 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXXFLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o rd_test $(LDFLAGS) 12 | 13 | clean: 14 | rm -f rd_test *.o 15 | -------------------------------------------------------------------------------- /examples/inline_var_variadic_write/main.cpp: -------------------------------------------------------------------------------- 1 | #include"rw.hpp" 2 | #include 3 | 4 | int main() { 5 | System::out.println("Hello, ", "World", "!"); 6 | System::out.print("Enter value: "); 7 | int valueX = 0, valueY = 0; 8 | System::in.read(valueX); 9 | System::in.read(valueY); 10 | System::out.println(valueX, "*", valueY, "=", (valueX*valueY)); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /examples/inline_var_variadic_write/rw.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __RDWR__H__ 2 | #define __RDWR__H__ 3 | 4 | #include 5 | #include 6 | 7 | namespace System { 8 | 9 | class output { 10 | public: 11 | output() = default; 12 | 13 | template 14 | void println(const T &type) { 15 | std::cout << type; 16 | } 17 | 18 | template 19 | void println(const T &type, Args... args) { 20 | println(type); 21 | println(args...); 22 | if(sizeof...(args) == 1) std::cout << "\n"; 23 | } 24 | 25 | template 26 | void print(const T &type) { 27 | std::cout << type; 28 | } 29 | 30 | template 31 | void print(const T &type, Args... args) { 32 | print(type); 33 | print(args...); 34 | } 35 | }; 36 | 37 | class input { 38 | public: 39 | input() = default; 40 | template 41 | void read(T &type) { 42 | std::cin >> type; 43 | } 44 | }; 45 | 46 | inline output out; 47 | inline input in; 48 | } 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /examples/julia/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=julia 3 | CFLAGS= -std=c++17 `pkg-config opencv4 --cflags` 4 | LDFLAGS= `pkg-config opencv4 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/julia/README.md: -------------------------------------------------------------------------------- 1 | 2 | Example: 3 | 4 | ./julia output.png 1920x1080 500 -0.7269,-0.189245125 50,75,150 16 5 | 6 | arguments: 7 | julia output.png WidthxHeight iterations paramA,paramB red,green,blue thread_count 8 | -------------------------------------------------------------------------------- /examples/karma/Makefile: -------------------------------------------------------------------------------- 1 | # program for fun 2 | FLAGS=-std=c++17 3 | 4 | all: 5 | g++ $(FLAGS) karma.cpp -o karma.out 6 | clean: 7 | rm -f karma.out 8 | -------------------------------------------------------------------------------- /examples/karma/karma.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Thought { 5 | public: 6 | std::string idea; 7 | }; 8 | 9 | Thought &get(Thought &thought) { 10 | std::cout << "Got info: " << thought.idea << "\n"; 11 | return thought; 12 | } 13 | Thought &give(Thought &thought) { 14 | std::cout << "Gave thought " << (thought.idea + "++") << "\n"; 15 | return thought; 16 | } 17 | 18 | void life() { 19 | Thought code; 20 | code.idea = "Cycle"; 21 | Thought think = get(give(code)); 22 | std::cout << "Karma returns: " << think.idea << "\n"; 23 | } 24 | 25 | 26 | int main(int argc, char **argv) { 27 | while(1) { 28 | life(); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /examples/karma_trail/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | per.test: $(OBJ) 10 | $(CXX) -o karma-trail $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | .PHONY: clean clear 15 | clean: 16 | rm -f karma-trail *.o 17 | -------------------------------------------------------------------------------- /examples/karma_trail/karma-trail.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 4 | Coma 5 | 6 | When you break the infinite while loop 7 | you branch out to the greater reality 8 | 9 | - Jared Bruni 10 | 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | class Escape {}; 18 | 19 | std::string give() { 20 | std::string data; 21 | std::cout << "Enter: "; 22 | std::getline(std::cin, data); 23 | return data; 24 | } 25 | 26 | std::string get(std::string data) { 27 | if(data == "love") 28 | std::cout << "love sent...\n"; 29 | else if(data == "fear") 30 | std::cout << "fear sent...\n"; 31 | else if(data == "break") 32 | throw Escape(); 33 | 34 | return data; 35 | } 36 | 37 | int main() { 38 | try { 39 | std::string trail; 40 | while(1) { 41 | trail += get(give()) + "\n"; 42 | std::cout << "karma trail: " << trail << "\n"; 43 | } 44 | } 45 | catch(Escape &e) { 46 | std::cout << "freedom..\n"; 47 | } 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /examples/libacidcam/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=libacidcam-test 3 | CFLAGS= -std=c++17 `pkg-config opencv4 acidcam --cflags` 4 | LDFLAGS= `pkg-config opencv4 acidcam --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/libacidcam/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/libacidcam/main.cpp: -------------------------------------------------------------------------------- 1 | // Arguments take the form of 2 | // --switch=value 3 | // --file=input-filename 4 | // --filter=index 5 | 6 | #include 7 | #include"ac.h" 8 | #include"cmd-switch.hpp" 9 | 10 | int main(int argc, char **argv) { 11 | try { 12 | cmd::ArgumentList argz(argc, argv); 13 | std::string filename; 14 | std::string filter; 15 | argz.require("--file", filename, "input video file"); 16 | argz.require("--filter", filter, "filter index"); 17 | 18 | ac::init(); 19 | cv::VideoCapture cap(filename); 20 | if(!cap.isOpened()) { 21 | std::cerr << "Could not open vidoe file: "<< filename << "\n"; 22 | exit(EXIT_FAILURE); 23 | } 24 | 25 | bool active = true; 26 | cv::namedWindow("acidcam"); 27 | int filter_index = atoi(filter.c_str()); 28 | 29 | if(filter_index < 0 || filter_index > ac::getFilterCount()-1) { 30 | std::cerr << "Error: invalid filter Index..\n"; 31 | exit(EXIT_FAILURE); 32 | } 33 | 34 | while(active) { 35 | cv::Mat frame; 36 | if(cap.read(frame)) { 37 | ac::CallFilter(filter_index, frame); 38 | cv::imshow("acidcam", frame); 39 | int key = cv::waitKey(10); 40 | if(key == 27) exit(EXIT_SUCCESS); 41 | } else break; 42 | } 43 | } catch(cmd::ArgExcep &e) { 44 | std::cerr << e.what() << "\n"; 45 | } 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /examples/linescroll/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=linescroll 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/linescroll/linescroll.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int main(int argc, char **argv) { 9 | if(argc != 3) { 10 | std::cerr << "Error incorrect arguments\n" << argv[0] << " text delay\n"; 11 | exit(EXIT_FAILURE); 12 | } 13 | std::string text = argv[1]; 14 | int time_wait = atoi(argv[2]); 15 | if(time_wait == 0) { 16 | std::cerr << "Error please use millisecond delay as second argument...\n"; 17 | exit(EXIT_FAILURE); 18 | } 19 | std::fstream file; 20 | file.open(text, std::ios::in); 21 | if(!file.is_open()) { 22 | std::cerr << "Error could not open file: " << text << "\n"; 23 | exit(EXIT_FAILURE); 24 | } 25 | 26 | while(!file.eof()) { 27 | std::string line; 28 | std::getline(file, line); 29 | if(file) { 30 | std::cout << line << "\n"; 31 | std::this_thread::sleep_for(std::chrono::milliseconds(time_wait)); 32 | } 33 | } 34 | file.close(); 35 | return EXIT_SUCCESS; 36 | } 37 | -------------------------------------------------------------------------------- /examples/linked_list/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS=-std=c++17 3 | 4 | list_test: main.cpp 5 | $(CXX) $(CXX_FLAGS) main.cpp -o list_test 6 | clean: 7 | rm -f list_test 8 | 9 | -------------------------------------------------------------------------------- /examples/linked_list/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=clang++ 2 | CXX_FLAGS=-std=c++1z 3 | 4 | list_test: main.cpp linked.hpp 5 | $(CXX) $(CXX_FLAGS) main.cpp -o list_test 6 | clean: 7 | rm -f list_test 8 | 9 | -------------------------------------------------------------------------------- /examples/linked_list/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include"linked.hpp" 5 | 6 | 7 | int main() { 8 | util::LinkedList lst; 9 | lst.add("Jared "); 10 | lst.add("Bruni"); 11 | lst.PrintList(); 12 | lst.remove(1); 13 | lst.PrintList(); 14 | lst.remove(0); 15 | util::LinkedList values; 16 | for(unsigned int i = 0; i < 15; ++i) { 17 | std::ostringstream stream; 18 | stream << "Value: " << i; 19 | values.add(stream.str()); 20 | } 21 | int index = 0; 22 | // new if statement 23 | if(util::Node *n = values.rootNode(); n != 0) { 24 | for(; n != 0; n = n->next) { 25 | std::cout << "At Index: " << index << " " << n->value << "\n"; 26 | ++index; 27 | } 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /examples/list2cpp/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=list2cpp 6 | 7 | %.o: %.cpp list2cpp.hpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/list2cpp/README.md: -------------------------------------------------------------------------------- 1 | Simple program that outputs header files using C++17's 2 | inline variables to use: 3 | 4 | 5 | to use const char *: 6 | 7 | $ list2cpp inputfile outputfile variable_name c 8 | 9 | to use std::string: 10 | 11 | $ list2cpp inputfile outputfile variable_name s 12 | 13 | to use a character array char arr[] 14 | 15 | $ list2cpp inputfile outputfile variable_name b 16 | 17 | or 18 | 19 | $ cat sourcefile | list2cpp variable_name s 20 | 21 | or 22 | 23 | $ cat sourcefile | list2cpp variable_name c 24 | 25 | or 26 | 27 | $ cat sourcefile | list2cpp variable_name b 28 | 29 | 30 | optional skip blank lines with p argument 31 | 32 | $ list2cpp inputfile outputfile varaiblename sp 33 | 34 | or skip lines with char array[]: 35 | 36 | $ cat source | list2cpp var_name bp 37 | 38 | optional sorting use g for greater than, l for less than like this 39 | 40 | for greater than sorting use 41 | 42 | $ list2cpp inputfile outputfile variable_name sg 43 | 44 | or less than sorting use 45 | 46 | $ list2cpp inputfile outputfile variablename sl 47 | 48 | also works with pipes 49 | 50 | $ cat sourcefile | list2cpp variable_name cl 51 | 52 | 53 | -------------------------------------------------------------------------------- /examples/list2cpp/list2cpp.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __LIST2CPP__H_ 2 | #define __LIST2CPP__H_ 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | namespace lst { 11 | enum class ListType { STRING, CHAR, BINARY}; 12 | class OutputList { 13 | public: 14 | OutputList() = default; 15 | OutputList(const OutputList &l); 16 | OutputList(OutputList &&); 17 | OutputList& operator=(OutputList &); 18 | OutputList& operator=(OutputList &&); 19 | void addItem(std::string item); 20 | bool addFile(std::string filename); 21 | bool addStream(std::istream &in); 22 | void sort(bool greater); 23 | std::size_t size() const { return items.size(); } 24 | bool outputToFile(std::string filename, std::string varname, ListType type); 25 | bool outputToFile(std::ostream &file, std::string varname, ListType type); 26 | void outputToFileAsBinary(std::ostream &file, std::string varname); 27 | void outputToFileAsChar(std::ostream &file, std::string varname); 28 | void outputToFileAsString(std::ostream &file, std::string varname); 29 | bool validName(const std::string &s); 30 | void setSkip(bool b) { skip_lines = b; } 31 | private: 32 | std::vector items; 33 | std::string escapeSequence(const std::string &s); 34 | bool skip_lines; 35 | }; 36 | } 37 | #endif 38 | 39 | -------------------------------------------------------------------------------- /examples/list2cpp/progtest/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS=-std=c++1z 3 | PROGRAM_NAME=headertest 4 | 5 | all: $(PROGRAM_NAME) 6 | 7 | $(PROGRAM_NAME): $(PROGRAM_NAME).cpp header.hpp 8 | $(CXX) $(CXX_FLAGS) $(PROGRAM_NAME).cpp -o $(PROGRAM_NAME) 9 | clean: 10 | rm -f $(PROGRAM_NAME) 11 | -------------------------------------------------------------------------------- /examples/list2cpp/progtest/headertest.cpp: -------------------------------------------------------------------------------- 1 | #include"header.hpp" 2 | #include"outputbytes.hpp" 3 | #include"headerchar.hpp" 4 | #include 5 | #include 6 | 7 | int main() { 8 | for(unsigned long i = 0; i < varname_size; ++i) { 9 | std::cout << varname_arr[i] << "\n"; 10 | } 11 | 12 | for(unsigned long i = 0; i < chvar_size; ++i) { 13 | std::cout << chvar_arr[i] << "\n"; 14 | } 15 | 16 | // std::cout << bytes_arr << "\n"; 17 | for(unsigned long i = 0; i < bytes_size; ++i) { 18 | std::cout << std::dec << "[" << i << "] = " << std::setfill('0') << std::setw(2) << std::hex << std::uppercase << static_cast(bytes_arr[i]) << "\n"; 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /examples/mandelbrot/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=mandelbrot 3 | CFLAGS= -std=c++17 `pkg-config opencv4 --cflags` 4 | LDFLAGS= `pkg-config opencv4 --libs` 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/mandelbrot/README.md: -------------------------------------------------------------------------------- 1 | Use: 2 | 3 | ./mandelbrot output.png 1920x1080 -2.0,2.0 -1.0,1.0 180 16 4 | 5 | arguments: 6 | mandelbrot output.png WidthxHeight upperleft_start,upperleft_stop, lowerright_start,lowerright_stop iterations thread_count; 7 | 8 | -------------------------------------------------------------------------------- /examples/mandelbrot/output.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus17.Examples/cb5cc03789da0d57e7b625ae1fd8a6981a1223df/examples/mandelbrot/output.png -------------------------------------------------------------------------------- /examples/per_karma_trail/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | per.test: $(OBJ) 10 | $(CXX) -o karma-trail $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | .PHONY: clean clear 15 | clean: 16 | rm -f karma-trail *.o 17 | -------------------------------------------------------------------------------- /examples/per_karma_trail/karma-trail.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Karma Trail 4 | Simple Concept 5 | 6 | Coma 7 | 8 | When you break the infinite while loop 9 | you branch out to the greater reality 10 | 11 | - Jared Bruni 12 | 13 | */ 14 | 15 | #include 16 | #include 17 | #include 18 | #include "per.hpp" 19 | 20 | class Escape {}; 21 | 22 | std::string give() { 23 | std::string data; 24 | std::cout << "Enter: "; 25 | std::getline(std::cin, data); 26 | return data; 27 | } 28 | 29 | std::string get(std::string data) { 30 | if(data == "love") 31 | std::cout << "love sent...\n"; 32 | else if(data == "fear") 33 | std::cout << "fear sent...\n"; 34 | else if(data == "break") 35 | throw Escape(); 36 | 37 | return data; 38 | } 39 | 40 | int main() { 41 | try { 42 | per::Per trail("karma_trail.txt", ""); 43 | while(1) { 44 | *trail += get(give()) + "\n"; 45 | std::cout << "karma trail: " << *trail << "\n"; 46 | } 47 | } 48 | catch(Escape &e) { 49 | std::cout << "freedom..\n"; 50 | } 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /examples/per_temp/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | per.test: $(OBJ) 10 | $(CXX) -o per.test $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | .PHONY: clean clear 15 | clean: 16 | rm -f per.test *.o 17 | clear: 18 | rm -f *.dat 19 | -------------------------------------------------------------------------------- /examples/per_temp/per.cpp: -------------------------------------------------------------------------------- 1 | #include"per.hpp" 2 | 3 | 4 | -------------------------------------------------------------------------------- /examples/persist_map/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | PERMAP=persist_map 5 | PERMAP_INT=persist_map_int 6 | PERCAT=persist_concat 7 | PERSTRUCT=persist_struct 8 | PERSTRING=persist_string 9 | 10 | all: $(PERMAP) $(PERMAP_INT) $(PERCAT) $(PERSTRUCT) $(PERSTRING) 11 | 12 | $(PERMAP): $(PERMAP).cpp permap.hpp 13 | $(CXX) $(CXX_FLAGS) $(PERMAP).cpp -o $(PERMAP) 14 | $(PERMAP_INT): $(PERMAP_INT).cpp permap.hpp 15 | $(CXX) $(CXX_FLAGS) $(PERMAP_INT).cpp -o $(PERMAP_INT) 16 | $(PERCAT): $(PERCAT).cpp permap.hpp 17 | $(CXX) $(CXX_FLAGS) $(PERCAT).cpp -o $(PERCAT) 18 | $(PERSTRUCT): $(PERSTRUCT).cpp permap.hpp 19 | $(CXX) $(CXX_FLAGS) $(PERSTRUCT).cpp -o $(PERSTRUCT) 20 | $(PERSTRING): $(PERSTRING).cpp permap.hpp 21 | $(CXX) $(CXX_FLAGS) $(PERSTRING).cpp -o $(PERSTRING) 22 | clean: 23 | rm -f $(PERMAP) $(PERMAP_INT) $(PERCAT) $(PERSTRUCT) $(PERSTRING) 24 | 25 | 26 | -------------------------------------------------------------------------------- /examples/persist_map/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=clang++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | PERMAP=persist_map 5 | PERMAP_INT=persist_map_int 6 | PERCAT=persist_concat 7 | PERSTRUCT=persist_struct 8 | PERSTRING=persist_string 9 | 10 | all: $(PERMAP) $(PERMAP_INT) $(PERCAT) $(PERSTRUCT) $(PERSTRING) 11 | 12 | $(PERMAP): $(PERMAP).cpp permap.hpp 13 | $(CXX) $(CXX_FLAGS) $(PERMAP).cpp -o $(PERMAP) 14 | $(PERMAP_INT): $(PERMAP_INT).cpp permap.hpp 15 | $(CXX) $(CXX_FLAGS) $(PERMAP_INT).cpp -o $(PERMAP_INT) 16 | $(PERCAT): $(PERCAT).cpp permap.hpp 17 | $(CXX) $(CXX_FLAGS) $(PERCAT).cpp -o $(PERCAT) 18 | $(PERSTRUCT): $(PERSTRUCT).cpp permap.hpp 19 | $(CXX) $(CXX_FLAGS) $(PERSTRUCT).cpp -o $(PERSTRUCT) 20 | $(PERSTRING): $(PERSTRING).cpp permap.hpp 21 | $(CXX) $(CXX_FLAGS) $(PERSTRING).cpp -o $(PERSTRING) 22 | clean: 23 | rm -f $(PERMAP) $(PERMAP_INT) $(PERCAT) $(PERSTRUCT) $(PERSTRING) 24 | 25 | 26 | -------------------------------------------------------------------------------- /examples/persist_map/persist_concat.cpp: -------------------------------------------------------------------------------- 1 | #include"permap.hpp" 2 | #include 3 | 4 | 5 | int main() { 6 | persist::PersistMap program_ran("ran.dat", persist::GenericRead, persist::GenericWrite); 7 | program_ran["run_times"]++; 8 | std::cout << "Program Ran: " << program_ran["run_times"] << "\n"; 9 | persist::PersistMap program_this("ran_this.dat", persist::GenericRead, persist::GenericWrite); 10 | program_this << program_ran; 11 | std::cout << "Enter some text: "; 12 | std::string text; 13 | std::cin >> text; 14 | program_ran[text] = rand()%0xFFFFFFFF; 15 | std::cout << "Concat PersistMap1, PersistMap2: \n"; 16 | for(auto i = program_ran->begin(); i != program_ran->end(); ++i) { 17 | std::cout << "Key: " << i->first << " " << " Value: " << i->second << "\n"; 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /examples/persist_map/persist_map.cpp: -------------------------------------------------------------------------------- 1 | // Enter quit for the requested key to quit program 2 | 3 | #include "permap.hpp" 4 | #include 5 | 6 | int main() { 7 | 8 | persist::PersistMap string_data("data.txt", [](std::fstream &file, std::string &val) { 9 | unsigned int value; 10 | file.read(reinterpret_cast(&value), sizeof(value)); 11 | char *buf = new char[value+1]; 12 | file.read(buf, value); 13 | buf[value] = 0; 14 | val = buf; 15 | delete [] buf; 16 | }, 17 | [](std::fstream &file, const std::string &val) { 18 | unsigned int value = val.length(); 19 | file.write(reinterpret_cast(&value), sizeof(value)); 20 | file.write(val.c_str(), value); 21 | }); 22 | while(1) { 23 | std::cout << "Enter key: "; 24 | std::string key_text; 25 | std::getline(std::cin, key_text); 26 | if(key_text == "quit") break; 27 | std::cout << "Enter key value: "; 28 | std::string key_value; 29 | std::getline(std::cin, key_value); 30 | string_data[key_text] = key_value; 31 | for (auto i = string_data->begin(); i != string_data->end(); ++i) { 32 | auto [s_key, s_value] = *i; 33 | std::cout << s_key << " = " << s_value << "\n"; 34 | } 35 | } 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /examples/persist_map/persist_map_int.cpp: -------------------------------------------------------------------------------- 1 | // Enter quit for the requested key to quit program 2 | // Enter erase to erase file/map 3 | 4 | #include"permap.hpp" 5 | #include 6 | #include 7 | 8 | int main() { 9 | persist::PersistMap int_map("int.txt",persist::GenericRead, persist::GenericWrite); 10 | while(1) { 11 | std::string key,value; 12 | std::cout << "Enter key: "; 13 | std::getline(std::cin, key); 14 | if(key == "quit") break; 15 | if(key == "erase") { 16 | int_map.EraseFile(); 17 | std::cout << "Erased..\n"; 18 | continue; 19 | } 20 | std::cout << "Enter value: "; 21 | std::getline(std::cin, value); 22 | int_map[key] = atoi(value.c_str()); 23 | 24 | std::cout << "\n\nCurrent Values: \n"; 25 | for(auto i = int_map->begin(); i != int_map->end(); ++i) { 26 | auto [map_key, map_value] = *i; 27 | std::cout << map_key << " = " << map_value << "\n"; 28 | } 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /examples/persist_map/persist_string.cpp: -------------------------------------------------------------------------------- 1 | // Enter quit as key to stop the loop and write to file 2 | #include 3 | #include 4 | #include"permap.hpp" 5 | 6 | // loop and print items in container 7 | template 8 | void printMap(Iter start, Iter stop) { 9 | while(start != stop) { 10 | auto [first, second] = *start; 11 | std::cout << first << ":\t" << second << "\n"; 12 | start++; 13 | } 14 | } 15 | 16 | int main() { 17 | // persist object 18 | persist::PersistMap string_map("strings.dat", persist::StringRead, persist::StringWrite); 19 | bool active = true; 20 | while(active) { 21 | std::string key, value; 22 | std::cout << "Enter key: "; 23 | std::getline(std::cin, key); 24 | if(key == "quit") { 25 | active = false; 26 | continue; 27 | } 28 | std::cout << "Enter value: "; 29 | std::getline(std::cin, value); 30 | string_map[key] = value; 31 | printMap(string_map->begin(), string_map->end()); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /examples/printlines/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.5 FATAL_ERROR) 2 | 3 | project(test01 LANGUAGES CXX) 4 | set(CMAKE_CXX_STANDARD 17) 5 | set(CMAKE_CXX_STANDARD_REQURIED ON) 6 | set(CMAKE_CXX_EXTENSIONS OFF) 7 | 8 | add_executable(print-lines printlines.cpp) 9 | -------------------------------------------------------------------------------- /examples/printlines/printlines.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main(int argc, char **argv) { 7 | if(argc != 2) { 8 | std::cerr << "Error: requires one argument.\nFile to print..\n"; 9 | exit(EXIT_FAILURE); 10 | } 11 | 12 | std::fstream file; 13 | file.open(argv[1], std::ios::in); 14 | if(!file.is_open()) { 15 | std::cerr << "Error could not open file: "<< argv[1] << "\n"; 16 | exit(EXIT_FAILURE); 17 | } 18 | unsigned int index = 1; 19 | while(!file.eof()) { 20 | std::string line; 21 | std::getline(file, line); 22 | if(file) 23 | std::cout << index++ << ": " << line << "\n"; 24 | } 25 | file.close(); 26 | exit(EXIT_SUCCESS); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/printlines_stdin/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.5 FATAL_ERROR) 2 | 3 | project(test01 LANGUAGES CXX) 4 | set(CMAKE_CXX_STANDARD 17) 5 | set(CMAKE_CXX_STANDARD_REQURIED ON) 6 | set(CMAKE_CXX_EXTENSIONS OFF) 7 | 8 | add_executable(print-lines printlines.cpp) 9 | -------------------------------------------------------------------------------- /examples/printlines_stdin/printlines.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main(int argc, char **argv) { 7 | std::istream &file = std::cin; 8 | unsigned int index = 1; 9 | while(!file.eof()) { 10 | std::string line; 11 | std::getline(file, line); 12 | if(file) 13 | std::cout << index++ << ": " << line << "\n"; 14 | } 15 | exit(EXIT_SUCCESS); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /examples/qt/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Window1 : QMainWindow { 5 | Q_OBJECT 6 | public: 7 | MainWindow(QWidget *parent = 0) : QMainWindow(parent) { 8 | } 9 | }; 10 | 11 | int main(int argc, char **argv) { 12 | QApplication app(argc, argv); 13 | Window1 win; 14 | win.show(); 15 | app.exec(); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /examples/qt/qt.pro: -------------------------------------------------------------------------------- 1 | ###################################################################### 2 | # Automatically generated by qmake (3.1) Tue May 11 10:16:48 2021 3 | ###################################################################### 4 | 5 | TEMPLATE = app 6 | TARGET = qt 7 | INCLUDEPATH += . 8 | 9 | # You can make your code fail to compile if you use deprecated APIs. 10 | # In order to do so, uncomment the following line. 11 | # Please consult the documentation of the deprecated API in order to know 12 | # how to port your code away from it. 13 | # You can also select to disable deprecated APIs only up to a certain version of Qt. 14 | #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 15 | 16 | # Input 17 | SOURCES += main.cpp 18 | -------------------------------------------------------------------------------- /examples/quine/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=Quine 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/quine/quine.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char **argv) 3 | { 4 | char quote = 34; 5 | const char *arr[] = { 6 | "#include", 7 | "int main(int argc, char **argv)", 8 | "{", 9 | " char quote = 34;", 10 | " const char *arr[] = {", 11 | " ", 12 | " };", 13 | " for(int i = 0; i < 5; ++i)", 14 | " std::cout << arr[i] << std::endl;", 15 | " for(int i = 0; i < 15; ++i)", 16 | " std::cout << arr[5] << quote << arr[i] << quote << ',' << std::endl;", 17 | " for(int i = 5; i < 15; ++i)", 18 | " std::cout << arr[i] << std::endl;", 19 | " return 0;", 20 | "}", 21 | 22 | }; 23 | for(int i = 0; i < 5; ++i) 24 | std::cout << arr[i] << std::endl; 25 | for(int i = 0; i < 15; ++i) 26 | std::cout << arr[5] << quote << arr[i] << quote << ',' << std::endl; 27 | for(int i = 5; i < 15; ++i) 28 | std::cout << arr[i] << std::endl; 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /examples/regex/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=regex-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/regex/r.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | 7 | if(argc != 2) { 8 | std::cerr << "Error requires one argument..\n"; 9 | exit(EXIT_FAILURE); 10 | } 11 | while(!std::cin.eof()) { 12 | std::string s; 13 | std::getline(std::cin, s); 14 | std::regex r(argv[1]); 15 | if(std::cin && std::regex_search(s, r)) { 16 | std::cout << argv[0] << ": match!\n"; 17 | } 18 | } 19 | 20 | return 0; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /examples/remember_words_qt/README.md: -------------------------------------------------------------------------------- 1 | Game to help improve my memory. 2 | You paste some text, the program grabs a number of words 3 | tells it to you then you have to enter that number of words in 4 | the exact order. If you are correct then it asks you to paste some 5 | new text and it increases the number of words it asks you to guess. 6 | 7 | 8 | -------------------------------------------------------------------------------- /examples/remember_words_qt/main.cpp: -------------------------------------------------------------------------------- 1 | #include "main_window.h" 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | QApplication app(argc, argv); 6 | MainWindow window1; 7 | window1.show(); 8 | return app.exec(); 9 | } 10 | -------------------------------------------------------------------------------- /examples/remember_words_qt/main_window.h: -------------------------------------------------------------------------------- 1 | #ifndef __MAINWINDOW__H__ 2 | #define __MAINWINDOW__H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | class MainWindow : public QMainWindow { 12 | Q_OBJECT 13 | public: 14 | MainWindow(QWidget *parent = 0); 15 | void createControls(); 16 | private: 17 | QTextEdit *textView1; 18 | QPushButton *startButton1, *giveupButton2; 19 | QCheckBox *reverseCheck1; 20 | int num_words; 21 | int mode; 22 | QStringList stored_list; 23 | 24 | QString defaultText = tr("This is where you can input some text to use with the program. It can contain any plain-text and the program will tokenize the string. Once the string is tokenized it will output a new string for you to read and then input again from memory. As you progress the string will get longer and longer. I wrote this to help with my memory. I love programming. This program is written in C++. It is written using the Qt library."); 25 | 26 | public slots: 27 | void startGame(); 28 | void giveup(); 29 | }; 30 | 31 | 32 | #endif 33 | 34 | -------------------------------------------------------------------------------- /examples/remember_words_qt/remember_words_qt.pro: -------------------------------------------------------------------------------- 1 | ###################################################################### 2 | # Automatically generated by qmake (3.1) Mon Oct 11 14:12:27 2021 3 | ###################################################################### 4 | 5 | TEMPLATE = app 6 | TARGET = remember_words_qt 7 | INCLUDEPATH += . 8 | QT += core gui 9 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets 10 | CONFIG += c++17 11 | # You can make your code fail to compile if you use deprecated APIs. 12 | # In order to do so, uncomment the following line. 13 | # Please consult the documentation of the deprecated API in order to know 14 | # how to port your code away from it. 15 | # You can also select to disable deprecated APIs only up to a certain version of Qt. 16 | #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 17 | 18 | # Input 19 | HEADERS += main_window.h 20 | SOURCES += main.cpp main_window.cpp 21 | -------------------------------------------------------------------------------- /examples/replace/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=replace-test 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/replace/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/replace/replace.cpp: -------------------------------------------------------------------------------- 1 | // use on the shell with pipe 2 | // example 3 | // cat text-file.txt | ./replace-test --repalce="string" --with="replacement" 4 | 5 | #include 6 | #include 7 | #include"cmd-switch.hpp" 8 | 9 | std::string replace_string(std::string orig, std::string with, std::string rep) { 10 | auto pos = orig.find(with); 11 | if(pos == std::string::npos) { 12 | return orig; 13 | } 14 | std::string left; 15 | left = orig.substr(0, pos); 16 | std::string right; 17 | right = orig.substr(pos+with.length(), orig.length()); 18 | 19 | std::string f; 20 | f = left+rep+right; 21 | return replace_string(f,with,rep); 22 | } 23 | 24 | int main(int argc, char **argv) { 25 | try { 26 | 27 | std::string rp; 28 | std::string re; 29 | cmd::ArgumentList argz(argc, argv); 30 | argz.require("--replace", rp, "replace string"); 31 | argz.require("--with", re, "replace with"); 32 | 33 | while(!std::cin.eof()) { 34 | std::string s; 35 | std::getline(std::cin, s); 36 | std::string output; 37 | output = replace_string(s, rp, re); 38 | std::cout << output << "\n"; 39 | } 40 | } 41 | catch(cmd::ArgExcep &e) { 42 | std::cerr << e.what() << "\n"; 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /examples/set/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=set-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/set/set.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | std::set ideas; 7 | std::string idea; 8 | while(1) { 9 | std::cout << "Enter idea: "; 10 | std::getline(std::cin, idea); 11 | ideas.insert(idea); 12 | for(auto i = ideas.begin(); i != ideas.end(); ++i) { 13 | std::cout << *i << "\n"; 14 | if(*i == "quit") exit(EXIT_SUCCESS); 15 | } 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /examples/shell_cmd/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.5 FATAL_ERROR) 2 | project(shell-cmd LANGUAGES CXX) 3 | 4 | if(NOT CMAKE_BUILD_TYPE) 5 | set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE) 6 | endif() 7 | 8 | message(STATUS "Build configuration is: ${CMAKE_BUILD_TYPE}") 9 | message(STATUS "is the C++ compiler loaded? ${CMAKE_CXX_COMPILER_LOADED}") 10 | 11 | if(CMAKE_CXX_COMPILER_LOADED) 12 | message(STATUS "The C++ Compiler ID is: ${CMAKE_CXX_COMPILER_ID}") 13 | message(STATUS "The C++ Compiler Version: ${CMAKE_CXX_COMPILER_VERSION}") 14 | endif() 15 | 16 | set(CMAKE_CXX_STANDARD 17) 17 | set(CMAKE_CXX_STANDARD_REQURIED ON) 18 | set(CMAKE_CXX_EXTENSIONS OFF) 19 | 20 | if(CMAKE_BUILD_TYPE STREQUAL "Release") 21 | list(APPEND COMPILER_FLAGS "-Wall" "-O2") 22 | else() 23 | message(STATUS "Debug Mode") 24 | list(APPEND COMPILER_FLAGS "-Wall" "-g") 25 | endif() 26 | 27 | 28 | add_executable(shell-cmd cmd.cpp) 29 | target_compile_options(shell-cmd PRIVATE ${COMPILER_FLAGS}) 30 | install(TARGETS shell-cmd DESTINATION bin) 31 | -------------------------------------------------------------------------------- /examples/shell_cmd/Makefile.cmd: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=shell-cmd 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | 13 | 14 | all: $(PROGRAM) 15 | 16 | .PHONY: clean 17 | clean: 18 | rm -f $(PROGRAM) *.o 19 | install: 20 | cp $(PROGRAM) /usr/local/bin 21 | -------------------------------------------------------------------------------- /examples/shell_cmd/README.md: -------------------------------------------------------------------------------- 1 | for Practice 2 | Use 3 | 4 | ./shell-cmd path "command %f" regex_search_pattern 5 | 6 | ex: 7 | 8 | ./shell-cmd . "cat %f" *.txt 9 | 10 | actual example extract all archives: 11 | 12 | $ shell-cmd . "7z e %f" *.7z 13 | 14 | to execute command for each file type within directory/subdirectory 15 | just written to practice 16 | 17 | to build 18 | 19 | $ mkdir build 20 | 21 | $ cd build 22 | 23 | $ cmake .. 24 | 25 | $ make 26 | 27 | 28 | -------------------------------------------------------------------------------- /examples/show_lines/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=show_lines 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/show_lines/show_lines.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int main(int argc, char **argv) { 10 | if(argc != 2) { 11 | std::cerr << "Error could incorrect arguments..\n"; 12 | exit(EXIT_FAILURE); 13 | } 14 | 15 | std::fstream file; 16 | file.open(argv[1], std::ios::in); 17 | if(!file.is_open()) { 18 | std::cerr << "Error could not open file...\n"; 19 | exit(EXIT_FAILURE); 20 | } 21 | std::stringstream stream; 22 | stream << file.rdbuf(); 23 | file.close(); 24 | std::vector values; 25 | while(!stream.eof()) { 26 | std::string s; 27 | std::getline(stream, s); 28 | values.push_back(s); 29 | } 30 | std::ostringstream s_len; 31 | s_len << values.size(); 32 | int vlength = s_len.str().size()+1; 33 | for(int i = 0; i < values.size(); ++i) { 34 | std::ostringstream strout; 35 | strout.width(vlength); 36 | strout.fill('0'); 37 | strout << (i+1); 38 | std::cout << strout.str() << ":\t" << values[i] << "\n"; 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /examples/shuffle_list/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=shuffle_list_cxx 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/shuffle_list/README.md: -------------------------------------------------------------------------------- 1 | Small tool good for shuffling small list of items 2 | like of file names etc 3 | 4 | $ cat lst_file | ./shuffle_list_cxx 5 | 6 | or 7 | 8 | $ ./shuffle_lsit_cxx source_file1 source2 source3 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /examples/shuffle_list/shuffle_list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | void read_stream(std::istream &in, std::vector &out); 10 | 11 | int main(int argc, char **argv) { 12 | std::vector vec; 13 | unsigned int seed = std::chrono::system_clock::now().time_since_epoch().count(); 14 | if(argc == 1) { 15 | read_stream(std::cin, vec); 16 | } else if(argc >= 2) { 17 | for(int i = 1; i < argc; ++i) { 18 | std::fstream file; 19 | file.open(argv[i], std::ios::in); 20 | if(file.is_open()) 21 | read_stream(file, vec); 22 | else { 23 | std::cerr << argv[0] << ": Error could not read file: " << argv[1] << "...\n"; 24 | exit(EXIT_FAILURE); 25 | } 26 | } 27 | } 28 | std::shuffle(vec.begin(), vec.end(), std::default_random_engine(seed)); 29 | for(auto &s : vec) { 30 | std::cout << s << "\n"; 31 | } 32 | return 0; 33 | } 34 | 35 | void read_stream(std::istream &in, std::vector &out) { 36 | while(!in.eof()) { 37 | std::string s; 38 | std::getline(in, s); 39 | if(in) 40 | out.push_back(s); 41 | } 42 | } 43 | 44 | -------------------------------------------------------------------------------- /examples/sort/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=sort-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/sort/sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | class Item { 6 | public: 7 | std::string name; 8 | int value; 9 | Item() : value{0} { 10 | 11 | } 12 | Item(int vvalue, std::string nname) : value{vvalue}, name{nname} {} 13 | 14 | bool operator<(const Item &i) const { 15 | return value items; 22 | while(1) { 23 | std::cout << "Enter items: "; 24 | std::string i, n; 25 | std::cout << "enter sort rank: "; 26 | std::getline(std::cin, i); 27 | std::cout << "enter name: "; 28 | std::getline(std::cin, n); 29 | int v = atoi(i.c_str()); 30 | Item index(v, n); 31 | items.push_back(index); 32 | std::sort(items.begin(), items.end()); 33 | for(auto it = items.begin(); it != items.end(); ++it) { 34 | std::cout << it->value << ":" << it->name << "\n"; 35 | } 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /examples/stack/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=stack 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/stack/main.cpp: -------------------------------------------------------------------------------- 1 | #include"stack.hpp" 2 | 3 | int main(int argc, char **argv) { 4 | try { 5 | Stack stack1(100); 6 | stack1.push(100); 7 | stack1.push(200); 8 | stack1.printItems(); 9 | int val = stack1.pop(); 10 | std::cout << "off top: " << val << "\n"; 11 | val = stack1.pop(); 12 | std::cout << "off top: " << val << "\n"; 13 | stack1.push(500); 14 | std::cout << "top: " << stack1.top() << "\n"; 15 | stack1.printItems(); 16 | } catch (ErrorUnder &eu) { 17 | std::cout << "underflow\n"; 18 | } catch (ErrorOver &eo) { 19 | std::cout << "overflow\n"; 20 | } catch (ErrorEmpty &ee) { 21 | std::cout << "Error Empty..\n"; 22 | } 23 | catch(...) { 24 | std::cout << "...\n"; 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /examples/stack/stack.hpp: -------------------------------------------------------------------------------- 1 | // trying to write something to practice 2 | #ifndef __HPP_HPP__ 3 | #define __HPP_HPP__ 4 | 5 | #include 6 | #include 7 | 8 | class ErrorUnder{}; 9 | class ErrorOver{}; 10 | class ErrorEmpty{}; 11 | 12 | template 13 | class Stack { 14 | public: 15 | Stack(int Size); 16 | ~Stack(); 17 | void push(const T &type); 18 | T pop(); 19 | T top(); 20 | size_t size() const { return size_of; } 21 | void printItems() const; 22 | protected: 23 | T *type; 24 | size_t size_of; 25 | size_t index; 26 | }; 27 | 28 | template 29 | Stack::Stack(int Size) { 30 | type = new T[Size+1]; 31 | size_of = Size; 32 | index = 0; 33 | } 34 | 35 | template 36 | Stack::~Stack() { 37 | delete [] type; 38 | type = nullptr; 39 | } 40 | 41 | template 42 | void Stack::push(const T &t) { 43 | if(index+1 < size_of) 44 | type[index++] = t; 45 | else 46 | throw ErrorOver(); 47 | } 48 | 49 | template 50 | T Stack::pop() { 51 | if(index-1 >= 0) { 52 | T t; 53 | t = type[--index]; 54 | return t; 55 | } 56 | else { 57 | throw ErrorUnder(); 58 | } 59 | } 60 | 61 | template 62 | T Stack::top() { 63 | if(index > 0) 64 | return type[index-1]; 65 | else 66 | throw ErrorEmpty(); 67 | } 68 | 69 | template 70 | void Stack::printItems() const { 71 | for(int i = 0; i < index; ++i) { 72 | std::cout << type[i] << "\n"; 73 | } 74 | } 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /examples/staticinitfree/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=staticif-test 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/staticinitfree/main.cpp: -------------------------------------------------------------------------------- 1 | #include"staticif.hpp" 2 | #include 3 | 4 | static st::staticIF startup([](){ 5 | std::cout << "seeding..\n"; 6 | srand(static_cast(time(0))); 7 | }, [](){ 8 | std::cout << "goodbye!\n"; 9 | }); 10 | 11 | int main(int argc, char **argv) { 12 | std::cout << "seeded random number: " << rand()%255 << "\n"; 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /examples/staticinitfree/staticif.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __STATIC_IF_HPP_ 2 | #define __STATIC_IF_HPP_ 3 | 4 | namespace st { 5 | 6 | class staticIF { 7 | public: 8 | template 9 | staticIF(F1 in, F2 out) { 10 | in(); 11 | release = out; 12 | } 13 | 14 | ~staticIF() { 15 | release(); 16 | } 17 | 18 | protected: 19 | //F2 free; 20 | void (*release)(); 21 | }; 22 | } 23 | 24 | 25 | #endif 26 | 27 | -------------------------------------------------------------------------------- /examples/stdin_to_bin/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=stdin_to_bin 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/stdin_to_bin/cmd-switch.cpp: -------------------------------------------------------------------------------- 1 | #include"cmd-switch.hpp" 2 | 3 | namespace cmd { 4 | 5 | ArgumentStringList::ArgumentStringList(int argc, char **argv) : argz {argc,argv} { 6 | 7 | } 8 | 9 | bool Argument_FindInList(std::vector &lst, ArgumentStringList &alst) { 10 | for(int i = 0; i < alst.argz.size(); ++i) { 11 | bool found = false; 12 | for(int z = 0; z < lst.size(); ++z) { 13 | if(alst.argz.item(i).key == "$") { 14 | if(alst.argz.item(i).value == lst[z]) { 15 | found = true; 16 | break; 17 | } 18 | } else { 19 | if(alst.argz.item(i).key == lst[z]) { 20 | found = true; 21 | break; 22 | } 23 | } 24 | } 25 | if(found == true) 26 | return true; 27 | } 28 | return false; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/stopwatch/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=watch_test 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/stopwatch/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include"stopwatch.hpp" 3 | 4 | 5 | void testFunc() { 6 | char a[2]; 7 | for(unsigned int i = 0; i < 1920*1080; ++i) 8 | a[0] = a[1] = rand()%255; 9 | } 10 | 11 | void averageTest() { 12 | std::cout << "Testing: "; 13 | long counter = 0; 14 | for(int index = 0; index < 100; ++index) { 15 | SystemClock clock; 16 | clock.start(); 17 | testFunc(); 18 | clock.stop(); 19 | counter += clock.timePassed(); 20 | std::cout << "."; 21 | fflush(stdout); 22 | } 23 | std::cout << "\n"; 24 | counter /= 100; 25 | std::cout << "Average time for testFunc: " << counter << " milliseconds\n"; 26 | } 27 | 28 | void testFunc2() { 29 | StopWatch counter("testFunc"); 30 | testFunc(); 31 | } 32 | 33 | int main(int argc, char **argv) { 34 | averageTest(); 35 | testFunc2(); 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /examples/strategy/Makefile: -------------------------------------------------------------------------------- 1 | 2 | 3 | CXX_FLAGS=-std=c++17 -O2 4 | SDL_CXXFLAGS= `sdl2-config --cflags` 5 | SDL_LDFLAGS= `sdl2-config --libs` -lSDL2_ttf 6 | CPP_FILES := $(wildcard *.cpp) 7 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 8 | OUTPUT_NAME=test-game 9 | 10 | %.o: %.cpp 11 | $(CXX) $(CXX_FLAGS) $(SDL_CXXFLAGS) -c -o $@ $< 12 | 13 | all: $(OBJ_FILES) 14 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) $(SDL_LDFLAGS) 15 | 16 | install: all 17 | cp $(OUTPUT_NAME) /usr/local/bin 18 | 19 | clean: 20 | rm -f $(OUTPUT_NAME) *.o 21 | -------------------------------------------------------------------------------- /examples/strategy/camera.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _CAMERA_H__ 2 | #define _CAMERA_H__ 3 | 4 | #include 5 | #include 6 | 7 | namespace game { 8 | 9 | class Camera { 10 | public: 11 | Camera(); 12 | Camera(int w, int h, int mx, int my); 13 | Camera(const Camera &c); 14 | 15 | Camera &operator=(const Camera &c); 16 | void init(int w, int h, int mx, int my); 17 | void move(float delta, float dx, float dy); 18 | int getX() const; 19 | int getY() const; 20 | int getWidth() const; 21 | int getHeight() const; 22 | void reset(); 23 | void set(const Camera &c); 24 | protected: 25 | int x,y,width,height,max_x,max_y,speed_x,speed_y; 26 | }; 27 | 28 | } 29 | 30 | #endif -------------------------------------------------------------------------------- /examples/strategy/game.cpp: -------------------------------------------------------------------------------- 1 | #include"game.hpp" 2 | 3 | 4 | namespace game { 5 | 6 | Color::Color(unsigned char rr, unsigned char gg, unsigned char bb) : r{rr}, g{gg}, b{bb} {} 7 | 8 | } -------------------------------------------------------------------------------- /examples/strategy/game.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _GAME_H_PP 2 | #define _GAME_H_PP 3 | #include 4 | #include 5 | #define DEBUG_MODE 6 | 7 | namespace game { 8 | 9 | struct Color { 10 | unsigned char r,g,b; 11 | Color() = default; 12 | Color(unsigned char r, unsigned char g, unsigned char b); 13 | }; 14 | 15 | enum Key { KEY_LEFT=1, KEY_RIGHT, KEY_UP, KEY_DOWN }; 16 | 17 | using Font = int; 18 | using Image = int; 19 | 20 | struct RenderObject { 21 | virtual ~RenderObject() = default; 22 | virtual void drawAt(Image image, int x, int y) = 0; 23 | virtual void drawAtRect(Image image, int x, int y, int w, int h) = 0; 24 | virtual void drawAtRect(Image image, int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2) = 0; 25 | virtual void printText(Font font, int x, int y, const std::string &text, const Color &col) = 0; 26 | virtual Font loadImage(const std::string &text) = 0; 27 | virtual void setImageColorKey(Image image, const Color &c) = 0; 28 | virtual Image loadFont(const std::string &text, int size) = 0; 29 | virtual unsigned int getTicks() = 0; 30 | virtual bool keyDown(const Key &c) = 0; 31 | }; 32 | 33 | struct GameObject { 34 | virtual ~GameObject() = default; 35 | virtual void init(RenderObject *ro) = 0; 36 | virtual void draw(RenderObject *ro) = 0; 37 | virtual void keydown(char key) = 0; 38 | virtual void keyup(char key) = 0; 39 | }; 40 | } 41 | 42 | #endif -------------------------------------------------------------------------------- /examples/strategy/game_level.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _GAME_LEVEL_H_ 2 | #define _GAME_LEVEL_H_ 3 | 4 | #include"camera.hpp" 5 | #include"level.hpp" 6 | #include"game.hpp" 7 | 8 | namespace game { 9 | class GameLevel : public GameObject { 10 | public: 11 | GameLevel() = default; 12 | void init(RenderObject *ro) override; 13 | void draw(RenderObject *ro) override; 14 | void keydown(char key) override; 15 | void keyup(char key) override; 16 | 17 | protected: 18 | Level level; 19 | Camera cam; 20 | Image brick; 21 | Font arial; 22 | int tsize; 23 | float delta; 24 | const int TILE_W=16; 25 | static const int WINDOW_SIZE_W = 1280/16; 26 | static const int WINDOW_SIZE_H = 720/16; 27 | }; 28 | } 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | #endif -------------------------------------------------------------------------------- /examples/strategy/img/arial.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus17.Examples/cb5cc03789da0d57e7b625ae1fd8a6981a1223df/examples/strategy/img/arial.ttf -------------------------------------------------------------------------------- /examples/strategy/img/brick.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus17.Examples/cb5cc03789da0d57e7b625ae1fd8a6981a1223df/examples/strategy/img/brick.bmp -------------------------------------------------------------------------------- /examples/strategy/level.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _LEVEL_H__ 2 | #define _LEVEL_H__ 3 | #include 4 | #include 5 | #include 6 | 7 | namespace game { 8 | 9 | struct Tile { 10 | Tile() = default; 11 | int32_t x = 0; 12 | int32_t y = 0; 13 | int32_t w = 0; 14 | int32_t h = 0; 15 | int32_t color = 0; 16 | int32_t solid = 0; 17 | int32_t img = 0; 18 | }; 19 | 20 | class Level { 21 | public: 22 | Level(); 23 | ~Level(); 24 | bool loadLevel(const std::string &filename); 25 | int width, height; 26 | void create(int w, int h, const Tile &init_tile); 27 | Tile *at(int x, int y); 28 | void output_map(std::ostream &out); 29 | protected: 30 | Tile **tiles; 31 | bool resizeTiles(int w, int h); 32 | void releaseTiles(); 33 | }; 34 | } 35 | 36 | #endif -------------------------------------------------------------------------------- /examples/strategy/main.cpp: -------------------------------------------------------------------------------- 1 | #include"window.hpp" 2 | #include"game_level.hpp" 3 | #include 4 | 5 | 6 | int main(int argc, char **argv) { 7 | int width = 1280, height = 720; 8 | if(argc == 3) { 9 | width = atoi(argv[1]); 10 | height = atoi(argv[2]); 11 | } 12 | if(!game::Window::createWindow("Game", width, height)) { 13 | std::cerr << "Error on init.\n"; 14 | return EXIT_FAILURE; 15 | } 16 | game::GameLevel level; 17 | game::Window::init_object(&level); 18 | game::Window::setObject(&level); 19 | return game::Window::loop(); 20 | } -------------------------------------------------------------------------------- /examples/strategy/window.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _GAME_H__P 2 | #define _GAME_H__P 3 | 4 | #include 5 | #include"game.hpp" 6 | 7 | namespace game { 8 | 9 | class Window { 10 | public: 11 | Window() = default; 12 | static bool createWindow(const std::string &title, int w, int h); 13 | static void setObject(GameObject *obj); 14 | static int loop(); 15 | static void quit(); 16 | static void init_object(GameObject *obj); 17 | protected: 18 | static bool active; 19 | static GameObject *current_object; 20 | }; 21 | 22 | } 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /examples/strategy/window_const.hpp: -------------------------------------------------------------------------------- 1 | #ifndef _WINDOW_CONST_H_ 2 | #define _WINDOW_CONST_H_ 3 | 4 | namespace game { 5 | const int WINDOW_SIZE_WIDTH = 1280; 6 | const int WINDOW_SIZE_HEIGHT = 720; 7 | } 8 | 9 | #endif -------------------------------------------------------------------------------- /examples/string_func/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=string 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/string_func/string.cpp: -------------------------------------------------------------------------------- 1 | // old school functions 2 | #include 3 | #include 4 | 5 | std::string mid(const std::string &src, size_t start, size_t stop) { 6 | std::string temp; 7 | for(size_t i = start; i < stop; ++i) { 8 | temp += src[i]; 9 | } 10 | return temp; 11 | } 12 | 13 | std::string left(const std::string &src, size_t num) { 14 | std::string temp; 15 | for(size_t i = 0; i < num; ++i) { 16 | temp += src[i]; 17 | } 18 | return temp; 19 | } 20 | 21 | std::string right(const std::string &src, size_t num) { 22 | std::string temp; 23 | for(size_t i = num; i < src.length(); ++i) { 24 | temp += src[i]; 25 | } 26 | return temp; 27 | } 28 | 29 | int main(int argc, char **argv) { 30 | std::string src="abc 123 efg"; 31 | std::string one, two, three; 32 | one=mid(src,3,5); 33 | std::cout << one << "\n"; 34 | two=left(src,3); 35 | std::cout << two << "\n"; 36 | three=right(src,3); 37 | std::cout << three << "\n"; 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /examples/string_list/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=slist 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/string_list/main.cpp: -------------------------------------------------------------------------------- 1 | #include "list.hpp" 2 | 3 | int main(int argc, char **argv) { 4 | lst::SList lst("test.txt"); 5 | std::cout << "enter value:"; 6 | std::string val1, val2; 7 | std::cin >> val1 >> val2; 8 | lst.set(val1, val2); 9 | lst.print(); 10 | return 0; 11 | 12 | } 13 | -------------------------------------------------------------------------------- /examples/symbol_table/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=sym-test 6 | 7 | %.o: %.cpp tree.hpp table.hpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/tab_space_swap/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=tabs2space 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/tab_space_swap/README.md: -------------------------------------------------------------------------------- 1 | Simple program use: 2 | 3 | $ cat source.txt | tabs2space t 4 >output.txt 4 | 5 | works with any output from other programs 6 | 7 | $ cat source.txt | tabs2space t 7 8 | 9 | also use s to convert a number of spaces in a row to tab 10 | 11 | works with any output from other programs 12 | 13 | $ cat source.txt | tabs2space s 4 >output.txt 14 | 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /examples/transform/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=transform-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | per.test: $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: example 13 | 14 | .PHONY: clean clear 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/transform/transform.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | std::vector half(std::vector values) { 7 | std::transform(values.begin(), values.end(), values.begin(), [](int v) { return v/2; }); 8 | return values; 9 | } 10 | 11 | // generic 12 | template 13 | void half_gen(Iter start, Iter stop) { 14 | std::transform(start, stop, start, [](auto v) { return v/2; }); 15 | } 16 | 17 | int main(int argc, char **argv) { 18 | std::vector v { 2,4,6,8, 24,36,96 }; 19 | std::vector v2 = half(v); 20 | std::for_each(v2.begin(), v2.end(), [](int i) { 21 | std::cout << "value: " << i << "\n"; 22 | }); 23 | std::vector v3 { 1.5, 2.6, 3.7, 4.9, 5.2 }; 24 | half_gen(v3.begin(), v3.end()); 25 | std::for_each(v3.begin(), v3.end(), [](double d) { 26 | std::cout << "value: " << d << "\n"; 27 | }); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/tree/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | LDFLAGS= 3 | CPP_FILES := $(wildcard *.cpp) 4 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 5 | OUTPUT_NAME=tree-test 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CXX_FLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o $(OUTPUT_NAME) $(LDFLAGS) 12 | 13 | install: all 14 | cp $(OUTPUT_NAME) /usr/local/bin 15 | 16 | clean: 17 | rm -f $(OUTPUT_NAME) *.o 18 | 19 | -------------------------------------------------------------------------------- /examples/ucase_stdin/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=std-test 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /examples/ucase_stdin/stdin_stdout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | // uppercase standard input stream 6 | int main(int argc, char **argv) { 7 | while(!std::cin.eof()) { 8 | int c = std::cin.get(); 9 | std::cout << static_cast(toupper(c)); 10 | } 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /examples/url_download/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXXFLAGS=-std=c++17 3 | LDFLAGS= 4 | CPP_FILES := $(wildcard *.cpp) 5 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 6 | 7 | %.o: %.cpp socket.hpp 8 | $(CXX) $(CXXFLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o url_download $(LDFLAGS) 12 | 13 | clean: 14 | rm -f url_download *.o 15 | -------------------------------------------------------------------------------- /examples/url_download/README.md: -------------------------------------------------------------------------------- 1 | This program will download a file from a HTTP server. 2 | Works with zip, gif, jpg,rar,html. This was written more for the Socket class 3 | then the actual program. I will use the socket class again in the future but doubt I will use 4 | this url downloader. 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /examples/variant/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | 3 | OUTPUT=var-ex 4 | CFLAGS= -std=c++17 5 | LDFLAGS= 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CFLAGS) $< -c -o $@ 9 | 10 | $(OUTPUT): $(OBJ) 11 | $(CXX) -o $(OUTPUT) $(OBJ) $(LDFLAGS) 12 | 13 | all: example 14 | 15 | .PHONY: clea 16 | clean: 17 | rm -f $(OUTPUT) *.o 18 | -------------------------------------------------------------------------------- /examples/variant/var-ex.cpp: -------------------------------------------------------------------------------- 1 | // visitor with std::variant 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | class ObjectType1 { 8 | public: 9 | ObjectType1() = default; 10 | int x = 1; 11 | }; 12 | 13 | class ObjectType2 { 14 | public: 15 | ObjectType2() = default; 16 | double x = 1.0; 17 | }; 18 | 19 | class PrintTypes { 20 | public: 21 | void operator()(const ObjectType1 &t) const { 22 | std::cout << "Type1: " << t.x << "\n"; 23 | } 24 | void operator()(const ObjectType2 &t) const { 25 | std::cout << "Type2: " << t.x << "\n"; 26 | } 27 | }; 28 | 29 | using obj_t = std::variant; 30 | using vobj_t = std::vector; 31 | 32 | void printAllTypes(const vobj_t &all) { 33 | for(auto &i : all) { 34 | std::visit(PrintTypes{}, i); 35 | } 36 | } 37 | 38 | int main(int argc, char **argv) { 39 | vobj_t obj_collection; 40 | obj_collection.push_back(ObjectType2{}); 41 | obj_collection.push_back(ObjectType1{}); 42 | printAllTypes(obj_collection); 43 | return 0; 44 | } 45 | 46 | -------------------------------------------------------------------------------- /examples/word_count/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=word_count 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | install: $(PROGRAM) 18 | cp $(PROGRAM) /usr/local/bin 19 | -------------------------------------------------------------------------------- /examples/word_count/README.md: -------------------------------------------------------------------------------- 1 | 2 | cat text_file | ./word_count 3 | 4 | will print out sorted list of each token and number of instances of each token 5 | 6 | -------------------------------------------------------------------------------- /examples/word_count/word_count.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | void extract_and_fill(std::istream &in, std::unordered_map &words); 8 | void sort_and_print(std::ostream &out, std::unordered_map &words); 9 | int main(int argc, char **argv) { 10 | std::unordered_map words; 11 | extract_and_fill(std::cin, words); 12 | sort_and_print(std::cout, words); 13 | return 0; 14 | } 15 | void extract_and_fill(std::istream &in, std::unordered_map &words) { 16 | std::string token; 17 | bool on = true; 18 | while(!in.eof()) { 19 | if(char c = tolower(in.get()); c >= 'a' && c <= 'z') { 20 | if(on == true) 21 | token += c; 22 | else { 23 | words[token]++; 24 | token = ""; 25 | token += c; 26 | on = true; 27 | } 28 | } else 29 | on = false; 30 | } 31 | if(token != "") 32 | words[token]++; 33 | } 34 | void sort_and_print(std::ostream &out, std::unordered_map &words) { 35 | std::vector keys; 36 | for(auto &i : words) 37 | keys.push_back(i.first); 38 | std::sort(keys.begin(), keys.end()); 39 | for(auto &i : keys) 40 | out << i << " " << words[i] << "\n"; 41 | } 42 | -------------------------------------------------------------------------------- /features/README.md: -------------------------------------------------------------------------------- 1 | Folder contains examples of using different features of C++17 2 | 3 | -------------------------------------------------------------------------------- /features/any/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/any/any.cpp: -------------------------------------------------------------------------------- 1 | // Cannot compile this myself as the version of the Standard Library it not up to date 2 | // will revisit this when I do. 3 | 4 | #include 5 | #include 6 | 7 | int main() { 8 | std::any value = 10; 9 | std::cout << std::any_cast(value) << "\n"; 10 | value = std::string("1 2 3"); 11 | std::cout << std::any_cast(value) << "\n"; 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /features/attributes/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=attrib 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/attributes/no-discard.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | [[nodiscard]] int *gen(); 4 | 5 | int main() { 6 | 7 | int *x = gen(); 8 | gen(); /// should warn return discarded. 9 | 10 | delete [] x; 11 | 12 | return 0; 13 | } 14 | 15 | [[nodiscard]] int *gen() { 16 | 17 | return new int[25]; 18 | } 19 | -------------------------------------------------------------------------------- /features/auto/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/auto/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/auto/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/auto/lambda.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Some ways you can use Lambdas 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | template 10 | void iterate(Iter start, Iter stop, F func) { 11 | while(start != stop){ 12 | func(*start); 13 | start++; 14 | } 15 | } 16 | 17 | int main() { 18 | std::vector value { 100, 200, 300, 400 }; 19 | iterate(value.begin(), value.end(),[](int x) { 20 | std::cout << "value: " << x << "\n"; 21 | }); 22 | iterate(value.begin(), value.end(), [](auto x) { 23 | std::cout << "value is: " << x << "\n"; 24 | }); 25 | auto f = [](auto x, auto y) { 26 | return (x+y); 27 | }; 28 | std::cout << "Value + is: " << f(100, 200) << "\n"; 29 | 30 | auto ConcatAddNewLine = [](std::string x, std::string y) -> std::string { 31 | return x+y+"\n"; 32 | }; 33 | std::string string1 = "Hello, "; 34 | std::string string2 = " World!"; 35 | std::cout << ConcatAddNewLine(string1, string2); 36 | std::cout << "Using auto: " << f(string1, string2) << "\n"; 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /features/compile_time/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/compile_time/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/compile_time/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/compile_time/arr_average.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Calculate Average of an Array at Compile Time 3 | */ 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | template 10 | constexpr T Average(const T *arr) { 11 | T total = T(); 12 | for(unsigned int i = 0; i < size; ++i) { 13 | total += arr[i]; 14 | } 15 | return total/size; 16 | } 17 | 18 | template 19 | class AverageT { 20 | public: 21 | static constexpr T value = Average(arr); 22 | }; 23 | 24 | constexpr int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 25 | 26 | int main() { 27 | constexpr int v = AverageT::value; 28 | std::cout << "Average calculated at Compile time: " << v << "\n"; 29 | 30 | // calculated size at compile time 31 | std::array::value> array_sized; 32 | for(std::size_t i = 0; i < array_sized.size(); ++i) { 33 | array_sized[i] = i*i; 34 | std::cout << "array at index: " << i << " := " << array_sized[i] << "\n"; 35 | } 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /features/compile_time/arr_sqrt.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Modified example from "C++ Templates the Complete Guide: Second Edition 4 | pg. 530 5 | 6 | */ 7 | 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | constexpr std::size_t SQRT_VALUE=10; 15 | 16 | template 17 | constexpr T my_sqrt(T x) { 18 | if(x <= 1) 19 | return x; 20 | 21 | T lo = 0, hi = x; 22 | while(1) { 23 | auto mid = (hi+lo)/2, midSquared= mid*mid; 24 | if(lo+1 >= hi || midSquared == x) { 25 | return mid; 26 | } 27 | if(midSquared < x) { 28 | lo = mid; 29 | } else { 30 | hi = mid; 31 | } 32 | } 33 | } 34 | 35 | int main() { 36 | constexpr auto sqrt_val = my_sqrt(SQRT_VALUE); 37 | // size of array is determined by calculating the square root of 10 38 | // at compile time 39 | std::array arr; 40 | for(unsigned int i = 0; i < sqrt_val; ++i) { 41 | arr[i] = 1; 42 | } 43 | std::cout << "Sqrt Value: " << sqrt_val << "\n"; 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /features/compile_time/constexpr_if.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | void println(const T &type, Args... args) { 5 | std::cout << type; 6 | if constexpr(sizeof...(args) > 0) // constexpr 7 | println(args...); 8 | else 9 | std::cout << "\n"; 10 | } 11 | 12 | int main() { 13 | println("Hello,", " World", "!"); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /features/compile_time/constexpr_if2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | void Only64(T type) { 5 | if constexpr( sizeof(type) > 4) { 6 | std::cout << "Greater than 4...\n"; 7 | } else { 8 | std::cout << "Less than equal 4...\n"; 9 | } 10 | } 11 | 12 | template 13 | class X { 14 | public: 15 | template 16 | void f(T2 t) { 17 | if constexpr(sizeof(t) == sizeof(T)) { 18 | std::cout << "Same size...\n"; 19 | } else { 20 | std::cout << "Not equal...\n"; 21 | } 22 | } 23 | }; 24 | 25 | template 26 | class Y { 27 | public: 28 | void test() { 29 | if constexpr(val == 55) { 30 | std::cout << "This code is generated only when val is equal to 55\n"; 31 | } else { 32 | std::cout << "Otherwise this code is generated..\n"; 33 | } 34 | } 35 | }; 36 | 37 | int main() { 38 | // some different tests 39 | Only64(10); 40 | Only64(10); 41 | X x; 42 | X y; 43 | int x_x = 10; 44 | long y_y = 20; 45 | x.f(y_y); 46 | x.f(x_x); 47 | y.f(y_y); 48 | y.f(x_x); 49 | Y<55> y_val; 50 | y_val.test(); 51 | Y<100> y_val2; 52 | y_val2.test(); 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /features/compile_time/constexpr_if3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | template 6 | void PrintValue(const T &type) { 7 | if constexpr(std::is_same::value) { 8 | std::cout << "Genreated for integer type..\n"; 9 | return; 10 | } 11 | else if constexpr(std::is_same::value) { 12 | std::cout << "Genreated for long...\n"; 13 | return; 14 | } 15 | else if constexpr(std::is_same::value) { 16 | std::cout << "String class...\n"; 17 | return; 18 | } else { 19 | std::cout << "Type not tested for...\n"; 20 | } 21 | } 22 | 23 | int main() { 24 | PrintValue(100); 25 | PrintValue(long(100000)); 26 | PrintValue(std::string("test")); 27 | PrintValue(100u); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /features/compile_time/prime_test.cpp: -------------------------------------------------------------------------------- 1 | // using the is_Prime constexpr function 2 | // at compile time, and at runtime 3 | 4 | #include 5 | 6 | constexpr bool is_Prime(unsigned int p) { 7 | for(unsigned int d=2; d<=p/2; ++d) { 8 | if((p%d) == 0) 9 | return false; 10 | } 11 | return p > 1; 12 | } 13 | 14 | template 15 | class Prime; 16 | 17 | template 18 | class Prime { 19 | public: 20 | static constexpr bool value = false; 21 | void print() { 22 | std::cout << N << " is not prime\n"; 23 | } 24 | }; 25 | 26 | template 27 | class Prime { 28 | public: 29 | static constexpr bool value = true; 30 | void print() { 31 | std::cout << N << " is prime\n"; 32 | } 33 | }; 34 | 35 | 36 | static_assert(Prime<7>::value, "Value is not prime"); 37 | //static_assert(Prime<9>::value, "Value is not prime"); // will cause compile time error 38 | 39 | int main() { 40 | std::cout << "Prime Numbers 1-100\n"; 41 | for(unsigned int i = 0; i < 100; ++i) { 42 | if(is_Prime(i)==true) 43 | std::cout << i << " is prime.\n"; 44 | } 45 | Prime<13> prime; 46 | prime.print(); 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /features/compile_time/primen.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | constexpr bool is_Prime(unsigned int p) { 4 | for(unsigned int d=2; d<=p/2; ++d) { 5 | if((p%d) == 0) 6 | return false; 7 | } 8 | return p > 1; 9 | } 10 | 11 | template 12 | class Prime; 13 | 14 | template 15 | class Prime { 16 | public: 17 | void print() { std::cout << "Value: " << N << " is not Prime..\n"; } 18 | }; 19 | 20 | template 21 | class Prime { 22 | public: 23 | void print() { std::cout << "Value: " << N << " is prime..\n"; } 24 | }; 25 | 26 | Prime<7> number; // calculate at compile time 27 | 28 | int main() { 29 | number.print(); 30 | // calculate at runtime 31 | for(unsigned int i = 0; i <= 100; ++i) { 32 | if(is_Prime(i)==true) 33 | std::cout << "Value: " << i << " is prime.\n"; 34 | else 35 | std::cout << "Value: " << i << " is not prime.\n"; 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /features/fold/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=fold-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/fold/fold.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | auto Add(Args&&... args) { 5 | return (args + ...); 6 | } 7 | 8 | 9 | template 10 | void printValues(Args&&... args) { 11 | (std::cout << ... << args) << '\n'; 12 | } 13 | 14 | int main() { 15 | 16 | int sum=Add(5,5,25); 17 | std::cout << "Sum is: " << sum << "\n"; 18 | 19 | std::string value; 20 | value=Add(std::string("value 1"), " + value 2 is this"); 21 | 22 | std::cout << value << "\n"; 23 | 24 | printValues(1, 2, 3, 4); 25 | printValues("one ", "two ", "three "); 26 | 27 | return 0; 28 | 29 | } 30 | -------------------------------------------------------------------------------- /features/function/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/function/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/function/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/function/func_test.cpp: -------------------------------------------------------------------------------- 1 | /* Some different ways you can use std::function */ 2 | #include 3 | #include 4 | #include 5 | 6 | 7 | void func_test(const std::string &x) { 8 | std::cout << "say: " << x << "\n"; 9 | } 10 | 11 | void for_loop(std::string word, int numTimes, std::function func) { 12 | for(int i = 0; i < numTimes; ++i) { 13 | std::cout << "at index: " << i << " "; 14 | func(word); 15 | } 16 | } 17 | 18 | int main() { 19 | 20 | std::function func1 = func_test; 21 | func_test("Hello World"); 22 | std::function printNum = [](int x) -> void { 23 | std::cout << "num value: " << x << "\n"; 24 | }; 25 | printNum(100); 26 | for_loop("Hey its me", 10, [](std::string n) -> void { 27 | std::cout << n << "\n"; 28 | }); 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /features/function/functor.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Functor { 5 | public: 6 | Functor(std::string v) : value(v) {} 7 | 8 | bool operator()(std::string cmp) { 9 | bool v = (value == cmp); 10 | if(v) 11 | std::cout << "Comparision Equal...\n"; 12 | else 13 | std::cout << "Comparision Not Equal...\n"; 14 | return v; 15 | } 16 | 17 | private: 18 | std::string value; 19 | }; 20 | 21 | template 22 | bool TestValue(F f, std::string v) { 23 | return f(v); 24 | } 25 | 26 | int main() { 27 | TestValue(Functor("Hello World"), "Hello World"); 28 | Functor f("Test"); 29 | TestValue(f, "Hey"); 30 | f("hey"); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /features/functional/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/functional/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/functional/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/functional/pure-func.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | The function always evaluates the same result value given the same argument value(s). 3 | The function result value cannot depend on any hidden information or state that may change 4 | while program execution proceeds or between different executions of the program, nor can 5 | it depend on any external input from I/O devices (usually—see below). 6 | Evaluation of the result does not cause any semantically observable side effect 7 | or output, such as mutation of mutable objects or output to I/O devices (usually—see below). 8 | */ 9 | 10 | #include 11 | #include 12 | 13 | std::string value="Jared B"; 14 | 15 | // pure function 16 | // evaluates the same result given the same argument values 17 | std::string function1(std::string &n) { 18 | return n+"runi"; 19 | } 20 | 21 | // impure function 22 | // any function that uses a non local variable 23 | std::string function2() { 24 | return value+"runi"; 25 | } 26 | 27 | int main() { 28 | // trying out the code 29 | std::string name = function1(value); 30 | std::cout << "pure function: " << name << "\n"; 31 | name = function1(value); 32 | std::cout << "pure function (again): " << name << "\n"; 33 | name = function2(); 34 | std::cout << "impure function: " << name << "\n"; 35 | value="B"; 36 | name = function2(); 37 | std::cout << "impure function after modifying non-local variable: " << name << "\n"; 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /features/getter/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=getter 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/getter/getter.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | class User { 6 | public: 7 | User(std::string n) : name{n} { 8 | 9 | } 10 | void setName(const std::string &n) { 11 | name = n; 12 | } 13 | // for move 14 | std::string getName() && { 15 | return std::move(name); 16 | } 17 | const std::string &getName() const& { 18 | return name; 19 | } 20 | 21 | protected: 22 | std::string name; 23 | 24 | }; 25 | 26 | User getUser() { 27 | return User("value"); 28 | } 29 | 30 | int main() { 31 | std::cout << "Enter name: "; 32 | std::string n; 33 | std::cin >> n; 34 | User u(n); 35 | std::cout << "Your name: " << u.getName() << "\n"; 36 | for(char c : u.getName()) { 37 | std::cout << c << "\n"; 38 | } 39 | for(char c : getUser().getName()) { 40 | std::cout << c << "\n"; 41 | } 42 | std::cout << getUser().getName() << "\n"; 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /features/hexadecimal-float/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/hexadecimal-float/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/hexadecimal-float/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/hexadecimal-float/hex_float.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | double value1 = 0xFF.2p3; // scaled by exponent 5 | double value2 = 0x1E.4p7; // scaled by exponent 6 | std::cout << value1 << " + " << value2 << " = " << (value1+value2) << "\n"; 7 | double value3 = 0x1.2p3; // 9 8 | std::cout << value3 << " + " << value3 << " = " << (value3+value3) << "\n"; 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /features/if_switch_variable_scope/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/if_switch_variable_scope/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/if_switch_variable_scope/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/if_switch_variable_scope/program.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | enum class Option { OP_1, OP_2, OP_3 }; 5 | Option o = Option::OP_1; 6 | for(unsigned int i = 0; i < 1000; ++i) { 7 | switch(Option q = o; q) { 8 | case Option::OP_1: 9 | o = Option::OP_2; 10 | std::cout << "Option 1\n"; 11 | break; 12 | case Option::OP_2: 13 | o = Option::OP_3; 14 | std::cout << "Option 2\n"; 15 | break; 16 | case Option::OP_3: 17 | o = Option::OP_1; 18 | std::cout << "Option 3\n"; 19 | break; 20 | } 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /features/if_switch_variable_scope/scope.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | C++17 Example 3 | tested with Clang-5.0 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | // function using if statement with new syntatic sugar 12 | template 13 | bool VecRemove(std::vector &vec, const T &search) { 14 | if(auto pos(std::find(vec.begin(), vec.end(), search)); pos != vec.end()) { 15 | vec.erase(pos); 16 | return true; 17 | } 18 | return false; 19 | } 20 | 21 | int main(int argc, char **argv) { 22 | std::vector v {"Jared", "Monkey", "Cow", "Turkey", "Pumpkin" }; 23 | // cool initilization for if statement 24 | if(int sz(v.size()); sz > 3) { 25 | std::cout << "Yeah it works value is: " << sz << "\n"; 26 | } 27 | // remove string Monkey from Vector 28 | if(VecRemove(v, "Monkey")) { 29 | std::cout << "Removed string\n"; 30 | } 31 | std::cout << "Enter character: \n"; 32 | // cool initalization statement for swtich 33 | switch(auto c(getchar()); c) { 34 | case 'q': 35 | exit(0); 36 | break; 37 | case 'b': 38 | std::cout << "You pressed b.\n"; 39 | break; 40 | default: 41 | std::cout << "You did not press b.\n"; 42 | } 43 | 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /features/inheritance/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/inheritance/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/inheritance/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/inheritance/variadic_inherit.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | class Object : public Base... { 6 | public: 7 | Object(Base... args) : Base(args)... {} 8 | 9 | void say(std::string s) { 10 | std::cout << s << "\n"; 11 | } 12 | }; 13 | 14 | class X { 15 | public: 16 | X(std::string value) : x(value) {} 17 | void sayX() { 18 | std::cout << "say: " << x << "\n"; 19 | } 20 | private: 21 | std::string x; 22 | }; 23 | 24 | class Y { 25 | public: 26 | Y(std::string value) : y(value) {} 27 | void sayY() { 28 | std::cout << "say: " << y << "\n"; 29 | } 30 | private: 31 | std::string y; 32 | }; 33 | 34 | int main() { 35 | Object object(X("Hello, "), Y("World!")); 36 | object.say("Hello World!"); 37 | object.sayX(); 38 | object.sayY(); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /features/inline_variables/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | CXX=g++ 3 | 4 | inline-test: point.cpp main.cpp point.hpp header_only.hpp 5 | $(CXX) $(CXX_FLAGS) point.cpp main.cpp -o inline-test 6 | 7 | clean: 8 | rm -f inline-test 9 | 10 | all: inline-test 11 | -------------------------------------------------------------------------------- /features/inline_variables/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++17 2 | 3 | CXX=clang++-5.0 4 | 5 | inline-test: point.cpp main.cpp point.hpp header_only.hpp 6 | $(CXX) $(CXX_FLAGS) point.cpp main.cpp -o inline-test 7 | 8 | clean: 9 | rm -f inline-test 10 | 11 | all: inline-test 12 | -------------------------------------------------------------------------------- /features/inline_variables/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++1z 2 | CXX=g++ 3 | 4 | inline-test: point.cpp main.cpp point.hpp header_only.hpp 5 | $(CXX) $(CXX_FLAGS) point.cpp main.cpp -o inline-test 6 | 7 | clean: 8 | rm -f inline-test 9 | 10 | all: inline-test 11 | -------------------------------------------------------------------------------- /features/inline_variables/README.md: -------------------------------------------------------------------------------- 1 | inline variables can be used for the creation of "header only" source files. 2 | where duplicate linking errors would occour in previous version of C++ in C++17 you can just add inline to 3 | the variable decleration and it will link to the right variable. This example is just some dummy classes I wrote 4 | to be able to test out inline to create a "header only" source file. 5 | 6 | 7 | -------------------------------------------------------------------------------- /features/inline_variables/header_only.hpp: -------------------------------------------------------------------------------- 1 | #ifndef HEADER_ONLY_H_ 2 | #define HEADER_ONLY_H_ 3 | 4 | #include 5 | 6 | namespace square { 7 | class Rect { 8 | int x, y, w, h; 9 | public: 10 | 11 | Rect() = default; 12 | Rect(int xx, int yy, int ww, int hh) : x(xx), y(yy), w(ww), h(hh) {} 13 | 14 | void set(int xx, int yy, int ww, int hh) { 15 | x = xx; 16 | y = yy; 17 | w = ww; 18 | h = hh; 19 | } 20 | 21 | void get(int &xx, int &yy, int &ww, int &hh) { 22 | xx = x; 23 | yy = y; 24 | ww = w; 25 | hh = h; 26 | } 27 | }; 28 | 29 | inline Rect background(0, 0, 640, 480); 30 | } 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /features/inline_variables/main.cpp: -------------------------------------------------------------------------------- 1 | #include"header_only.hpp" 2 | #include "point.hpp" 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | std::cout << "Hello C++17!\n"; 7 | int x = 0,y = 0,w = 0,h = 0; 8 | square::background.get(x,y,w,h); 9 | std::cout << "Rect is: " << x << ", " << y << ", " << w << ", " << h << "\n"; 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /features/inline_variables/point.cpp: -------------------------------------------------------------------------------- 1 | #include "point.hpp" 2 | 3 | namespace point { 4 | 5 | void Point::set(int xx, int yy) { 6 | x = xx; 7 | y = yy; 8 | } 9 | 10 | void Point::get(int &xx, int &yy) { 11 | xx = x; 12 | yy = y; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /features/inline_variables/point.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __POINT_H__ 2 | #define __POINT_H__ 3 | 4 | #include"header_only.hpp" 5 | 6 | namespace point { 7 | 8 | class Point { 9 | int x,y; 10 | public: 11 | void set(int xx, int yy); 12 | void get(int &xx, int &yy); 13 | }; 14 | } 15 | 16 | 17 | 18 | 19 | 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /features/invoke/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/invoke/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/invoke/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/invoke/invoke_test.cpp: -------------------------------------------------------------------------------- 1 | 2 | // for some reason on clang++-5.0 library invoke is declared __invoke 3 | // uncomment below if using a clang++-5.0 for Linux 4 | //#define invoke __invoke 5 | 6 | // invoke will allow you to use different types to be called including, function, function pointer 7 | // functor or member function pointer 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | template 15 | void my_foreach(It start, It stop, Call call, Args... args) { 16 | while(start != stop) { 17 | std::invoke(call, args..., *start); 18 | start++; 19 | } 20 | } 21 | 22 | class ProcOutput { 23 | public: 24 | void operator()(int x) { 25 | std::cout << "Value +1 is: " << (x+1) << "\n"; 26 | } 27 | 28 | void memfunc(int x) { 29 | std::cout << "Value -1 is: " << (x-1) << "\n"; 30 | } 31 | }; 32 | 33 | int main() { 34 | std::vector values {0,2,8,12,64,128,69,48,180}; 35 | my_foreach(values.begin(), values.end(), [](int value) { 36 | std::cout << "Value is: " << value << "\n"; 37 | }); 38 | my_foreach(values.begin(), values.end(), ProcOutput()); 39 | ProcOutput proc; 40 | my_foreach(values.begin(), values.end(), &ProcOutput::memfunc, proc); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /features/move/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=move-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/move/move.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | class User { 6 | public: 7 | User() = default; 8 | User(std::string n) : name{n} {} 9 | ~User() = default; 10 | User(const User &u) : name {u.name} { 11 | std::cout << "** copy constructor \n"; 12 | } 13 | User(User &&u) : name {std::move(u.name)} { 14 | std::cout << "** move cønstructor \n"; 15 | } 16 | User &operator=(const User &u) { 17 | name = u.name; 18 | std::cout << "** operator = &\n"; 19 | return *this; 20 | } 21 | User &operator=(User &&u) { 22 | std::cout << "** operator = &&\n"; 23 | name = std::move(u.name); 24 | return *this; 25 | } 26 | std::string getName() && { return std::move(name); } 27 | const std::string &getName() const & { return name; } 28 | protected: 29 | std::string name; 30 | }; 31 | 32 | User newName(std::string name) { 33 | return User(name); 34 | } 35 | 36 | int main() { 37 | std::cout << newName("hello").getName() << "\n"; 38 | for (char c : newName("test").getName()) { 39 | std::cout << c << "\n"; 40 | } 41 | User u("test 1 2 3"); 42 | std::cout << u.getName() << "\n"; 43 | User u2 { std::move(u) }; 44 | std::cout << u2.getName() << "\n"; 45 | User u3; 46 | u3 = u2; 47 | std::cout << u3.getName() << "\n"; 48 | u3 = User("test 1 3 3 4"); 49 | std::cout << u3.getName() << "\n"; 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /features/nested_namespace_def/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/nested_namespace_def/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/nested_namespace_def/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/nested_namespace_def/nested_namespace.cpp: -------------------------------------------------------------------------------- 1 | 2 | // C++17 Example 3 | 4 | #include"nested_namespace.hpp" 5 | 6 | // namespace sub/namespaces can be declared in single statement 7 | // with new Nested namespace definition 8 | namespace X::Y::Z { 9 | int x = 0; 10 | } 11 | 12 | // output value 0 for x 13 | int main(int argc, char **argv) { 14 | std::cout << "Value X: " << X::Y::Z::x << "\n"; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /features/nested_namespace_def/nested_namespace.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __NAMESPACE_F_H__ 2 | #define __NAMESPACE_F_H__ 3 | 4 | #include 5 | 6 | namespace X { 7 | namespace Y { 8 | namespace Z { 9 | extern int x; 10 | } 11 | } 12 | } 13 | 14 | 15 | #endif 16 | 17 | -------------------------------------------------------------------------------- /features/optional/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=op-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/optional/op.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | std::optional getCmd() { 6 | std::optional op; 7 | std::cout << "enter command: (quit/print) "; 8 | std::string s; 9 | std::cin >> s; 10 | if(s == "quit") 11 | op = 1; 12 | else if(s == "print") 13 | op = 2; 14 | 15 | return op; 16 | } 17 | 18 | int main() { 19 | 20 | auto i = getCmd(); 21 | if(i) { 22 | std::cout << "Command is: " << *i << "\n"; 23 | switch(*i) { 24 | case 1: 25 | std::cout << "Goodbye!.\n"; 26 | exit(0); 27 | break; 28 | case 2: 29 | std::cout << "Print...\n"; 30 | break; 31 | } 32 | } else { 33 | std::cout << "Unknown command: \n"; 34 | } 35 | 36 | 37 | 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /features/parallel/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=par-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/parallel/par.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | std::vector v; 8 | v.reserve(100); 9 | for(int i = 0; i < 100; ++i) { 10 | v.push_back(i); 11 | } 12 | for_each(std::execution::par, v.begin(), v.end(), [](auto &i) { 13 | std::cout << i << "\n"; 14 | }); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /features/policy_and_traits/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/policy_and_traits/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/policy_and_traits/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/policy_and_traits/error_int.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | class isOfType { 6 | public: 7 | static constexpr bool value = false; 8 | }; 9 | 10 | template 11 | class isOfType { 12 | public: 13 | static constexpr bool value = true; 14 | }; 15 | 16 | template 17 | class ErrorInt { 18 | public: 19 | static_assert(isOfType::value == false, "Error int not supported for this type"); 20 | }; 21 | 22 | int main() { 23 | ErrorInt value1; 24 | ErrorInt value2; 25 | // uncomment below to for it cause an error 26 | // ErrorInt err; 27 | std::cout << "Error Int\n"; 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /features/policy_and_traits/hasdefault.cpp: -------------------------------------------------------------------------------- 1 | // written by Jared Bruni 2 | #include 3 | #include 4 | #include 5 | 6 | // will be able to tell us whether or not a type has a default constructor 7 | template 8 | class HasDefaultConstructor { 9 | private: 10 | template 11 | static std::true_type test(void*); 12 | 13 | template 14 | static std::false_type test(...); 15 | public: 16 | static constexpr bool value = std::is_same(nullptr)), std::true_type>::value; 17 | }; 18 | 19 | class X { 20 | public: 21 | X() = default; 22 | }; 23 | 24 | class Y { 25 | public: 26 | Y() = delete; 27 | Y(int) {} 28 | }; 29 | 30 | class Z { 31 | public: 32 | Z() = default; 33 | }; 34 | 35 | template 36 | void PrintOut(T type) { 37 | if(HasDefaultConstructor::value) { 38 | std::cout << "Has Default Constructor...\n"; 39 | } else { 40 | std::cout << "Doesn't have Default Constructor...\n"; 41 | } 42 | } 43 | 44 | int main() { 45 | PrintOut(X()); // true 46 | PrintOut(Y(int())); // false 47 | PrintOut(Z());// true 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /features/policy_and_traits/isdefaulttype.cpp: -------------------------------------------------------------------------------- 1 | //Based on C++ Templates Complete Guide: Second Edition Chapter 19 section 19.8.1 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | template 8 | class isBuiltIn : public std::false_type { 9 | public: 10 | 11 | }; 12 | 13 | #define BUILT_IN(T) \ 14 | template<> class isBuiltIn : public std::true_type { \ 15 | public: \ 16 | }; 17 | 18 | 19 | BUILT_IN(long double) 20 | BUILT_IN(double) 21 | BUILT_IN(float) 22 | BUILT_IN(unsigned long long) 23 | BUILT_IN(signed long long) 24 | BUILT_IN(unsigned long) 25 | BUILT_IN(signed long) 26 | BUILT_IN(unsigned int) 27 | BUILT_IN(signed int) 28 | BUILT_IN(unsigned short) 29 | BUILT_IN(signed short) 30 | BUILT_IN(unsigned char) 31 | BUILT_IN(signed char) 32 | BUILT_IN(wchar_t) 33 | BUILT_IN(char16_t) 34 | BUILT_IN(char32_t) 35 | BUILT_IN(bool) 36 | BUILT_IN(void) 37 | 38 | 39 | template 40 | void isType(const T &type) { 41 | if constexpr(isBuiltIn::value) { 42 | std::cout << "Yes it is a built in type...\n"; 43 | } else { 44 | std::cout << "No it is not a built in type...\n"; 45 | } 46 | } 47 | 48 | template 49 | void isType(const T &type, Args... args) { 50 | isType(type); 51 | isType(args...); 52 | } 53 | 54 | int main() { 55 | int a = 100; 56 | long b = 200; 57 | std::string test = "Hello"; 58 | short c = 55; 59 | unsigned long long cpp = 100; 60 | isType(a,b,test,c,cpp); 61 | return 0; 62 | } 63 | -------------------------------------------------------------------------------- /features/policy_and_traits/isoftype.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | class isOfType { 6 | public: 7 | static constexpr bool value = false; 8 | }; 9 | 10 | template 11 | class isOfType { 12 | public: 13 | static constexpr bool value = true; 14 | }; 15 | 16 | template 17 | void testType(T type) { 18 | if(isOfType::value) { 19 | std::cout << "value is of type int...\n"; 20 | } else if(isOfType::value) { 21 | std::cout << "value is of type float...\n"; 22 | } else { 23 | std::cout << "value is of type (typeid): " << typeid(T).name() << "\n"; 24 | } 25 | } 26 | 27 | template 28 | void testType(T type, Args... args) { 29 | testType(type); 30 | testType(args...); 31 | } 32 | 33 | int main() { 34 | testType(50, 100, 0.5f, 0.1f, 100u, std::vector()); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /features/polymorphism/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/polymorphism/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/polymorphism/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/string/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=string-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/string/string-test.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | int count_zeros(const std::string &text) { 6 | int count = 0; 7 | for(auto &i : text) { 8 | if(i == '0') ++count; 9 | } 10 | return count; 11 | } 12 | 13 | template 14 | int count_chars(char c, Iter start, Iter stop) { 15 | int count = 0; 16 | for(Iter i = start; i != stop; ++i) { 17 | if(*i == c) ++count; 18 | } 19 | return count; 20 | } 21 | 22 | int main() { 23 | // convert integer to string 24 | std::cout << "Value: "; 25 | int x = 0; 26 | std::cin >> x; 27 | std::string temp; 28 | temp = std::to_string(x); 29 | std::cout << "value is: " + temp << "\n"; 30 | std::cout << count_chars('0', temp.begin(), temp.end()) << " zeros in string with template.\n"; 31 | 32 | std::cout << "number of zeros: " << count_zeros(temp) << "\n"; 33 | std::cout << count_zeros("1000") << " zeros in 1000\n"; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /features/string_view/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=string_view-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/string_view/sv.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void print_hello(std::string_view sv) { 6 | std::cout << "Hello: " << sv << "\n"; 7 | } 8 | 9 | int main() { 10 | print_hello("Jared"); 11 | print_hello("Person"); 12 | std::string value{" test 1 2 3 "}; 13 | print_hello(value); 14 | std::string_view sv{value}; 15 | const void *ptr = sv.data(); 16 | int sz = sv.size(); 17 | std::cout << "sv: size: " << sz << "\n"; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /features/structured_bindings/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/structured_bindings/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/structured_bindings/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/structured_bindings/sb.cpp: -------------------------------------------------------------------------------- 1 | /// This is untested doesn't have compiler support yet 2 | // but Structured bindings will break pair, tuple, struct into separete variables 3 | 4 | 5 | #include 6 | #include 7 | 8 | // just for getting a value 9 | std::pair getValue() { 10 | std::pair p("Jared", 100); 11 | return p; // RVO 12 | } 13 | 14 | 15 | int main(int argc, char **argv) { 16 | std::cout << "Test program.\n"; 17 | auto [first, second] = getValue(); // any pair variable 18 | std::cout << "First: " << first << " Second: " << second << "\n"; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /features/template/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template/erase_arr.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | template 6 | void erase_array(T **type, unsigned long size) { 7 | for(unsigned long i = 0; i < size; ++i) 8 | delete [] type[i]; 9 | 10 | delete [] type; 11 | } 12 | 13 | template 14 | T **new_dim(unsigned long x, unsigned long y) { 15 | T **type = new T*[x]; 16 | for(unsigned long i = 0; i < x; ++i) { 17 | type[i] = new T[y]; 18 | } 19 | return type; 20 | } 21 | 22 | int main() { 23 | std::cout << "Filling array...\n"; 24 | unsigned long size_x = 10; 25 | char **array_ = new_dim(size_x, 100); 26 | // fill with junk 27 | for(unsigned i = 0; i < 10; ++i) { 28 | sprintf(array_[i], "%s", "Hello World!"); 29 | std::cout << array_[i] << "\n"; 30 | } 31 | erase_array(array_, 10); 32 | std::cout << "Erased...\n"; 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /features/template/for_each.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | template 6 | void foreach(Iter start, Iter stop, Func f) { 7 | while(start != stop) { 8 | f(*start); 9 | start++; 10 | } 11 | } 12 | 13 | int main(int argc, char **argv) { 14 | std::vector v {1,2,8,49,5920,881,2,4,1}; 15 | foreach(v.begin(), v.end(), [](int x) { std::cout << "val: " << x << "\n"; }); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /features/template/variable_template.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | template 6 | constexpr T pi = T(3.1415926535897932385L); 7 | 8 | template 9 | using Vec = std::vector; 10 | 11 | template 12 | using StringKeyMap = std::unordered_map; 13 | 14 | template 15 | T carea(T r) { 16 | return pi * r * r; 17 | } 18 | 19 | template 20 | void printMap(Iter start, Iter stop) { 21 | while(start != stop) { 22 | auto [key,value] = *start; 23 | std::cout << key << ":" << value << "\n"; 24 | start++; 25 | } 26 | } 27 | 28 | int main() { 29 | Vec v; 30 | StringKeyMap values; 31 | float val = carea(10.f); 32 | std::cout << "Area: " << val << "\n"; 33 | values["test1"] = 1; 34 | values["test2"] = 2; 35 | printMap(values.begin(), values.end()); 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /features/template_argument/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_argument/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | argstest: args.cpp 5 | $(CXX) $(CXX_FLAGS) args.cpp -o argstest 6 | all: argstest 7 | 8 | clean: 9 | rm -f argstest 10 | -------------------------------------------------------------------------------- /features/template_argument/args.cpp: -------------------------------------------------------------------------------- 1 | // Adapted from C++ Templates: The Complete Guide Second Edition example 2 | 3 | #include 4 | #include 5 | 6 | 7 | class UnderFlow {}; 8 | 9 | template 10 | class Stack { 11 | public: 12 | Stack() = default; 13 | Stack(T type) : vec({type}) {} 14 | void push(const T &type) { 15 | vec.push_back(type); 16 | } 17 | T &top() { 18 | if(vec.size()==0) 19 | throw UnderFlow(); 20 | return vec.back(); 21 | } 22 | void pop() { 23 | if(vec.size()==0) 24 | throw UnderFlow(); 25 | vec.pop_back(); 26 | } 27 | void print() { 28 | std::cout << "Stack = { "; 29 | for(auto &i : vec) { 30 | std::cout << i << " "; 31 | } 32 | std::cout << "};\n"; 33 | } 34 | private: 35 | std::vector vec; 36 | }; 37 | 38 | 39 | int main() { 40 | try { 41 | Stack value{100.5}; // deduce argument 42 | Stack test_value = 500; // deduce argument 43 | value.print(); 44 | 45 | for(int i = 0; i < 10; ++i) 46 | test_value.push(i); 47 | 48 | test_value.print(); 49 | 50 | } catch(UnderFlow &e) { 51 | std::cerr << "Stack Underflow..\n"; 52 | } 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /features/template_auto/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_auto/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_auto/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_auto/template_auto.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // will choose type of array by the variable used for its size 4 | // there are better uses for this feature 5 | template 6 | class MatrixSxS { 7 | public: 8 | using size_type = decltype(S); 9 | MatrixSxS(); 10 | auto sizeLength(); 11 | void setPos(const size_type &pos_x, const size_type &pos_y,const size_type &value); 12 | auto value(const size_type &pos_x, const size_type &pos_y) const { return matrix[pos_x][pos_y]; } 13 | void print(); 14 | private: 15 | size_type matrix[S][S]; 16 | }; 17 | 18 | template 19 | MatrixSxS::MatrixSxS() { 20 | 21 | } 22 | 23 | template 24 | auto MatrixSxS::sizeLength() { 25 | return S; 26 | } 27 | 28 | template 29 | void MatrixSxS::setPos(const size_type &pos_x, const size_type &pos_y, const size_type &value) { 30 | matrix[pos_x][pos_y] = value; 31 | } 32 | 33 | template 34 | void MatrixSxS::print() { 35 | for(size_type i = 0; i < S; ++i) { 36 | for(size_type z = 0; z < S; ++z) { 37 | std::cout << "x: " << i << " y: " << z << " " << matrix[i][z] << "\n"; 38 | } 39 | } 40 | } 41 | 42 | int main() { 43 | MatrixSxS<8> int_values; 44 | MatrixSxS<16u> uint_values; 45 | for(int i = 0; i < 8; ++i) { 46 | for(int z = 0; z < 8; ++z) { 47 | int_values.setPos(i, z, (i*z)); 48 | } 49 | } 50 | int_values.print(); 51 | for(unsigned int ix = 0; ix < 16; ++ix) { 52 | for(unsigned int zx = 0; zx < 16; ++zx) { 53 | uint_values.setPos(ix, zx, (ix*zx)); 54 | } 55 | } 56 | uint_values.print(); 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /features/template_forward/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_forward/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_forward/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_forward/template_enable_if.cpp: -------------------------------------------------------------------------------- 1 | /* Concept from "C++ Templates the Complete Guide: Second Edition 2 | Chapter 6 3 | 4 | Using std::forward and std::enable_if_t 5 | 6 | */ 7 | 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | template 16 | using enable_string = std::enable_if_t::value>; 17 | 18 | class User { 19 | public: 20 | template> 21 | explicit User(S&& str) : name(std::forward(str)) { 22 | std::cout << "Called String&&\n"; 23 | } 24 | User(const User &u) : name(u.name) { 25 | std::cout << "Called &\n"; 26 | } 27 | User(User &&p) : name(std::move(p.name)) { 28 | std::cout << "Called User &&\n"; 29 | } 30 | void print() { 31 | std::cout << "My Username is: " << name << "\n"; 32 | } 33 | private: 34 | std::string name; 35 | }; 36 | 37 | int main() { 38 | std::string username; 39 | std::cout << "Enter username: "; 40 | std::getline(std::cin, username); 41 | User u1(username); 42 | User u2("temporary"); 43 | User u3(u1); 44 | User u4(std::move(u1)); 45 | u2.print(); 46 | u3.print(); 47 | u4.print(); 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /features/template_forward/template_forward.cpp: -------------------------------------------------------------------------------- 1 | /* Concept from "C++ Templates the Complete Guide: Second Edition 2 | Chapter 6 3 | */ 4 | 5 | 6 | #include 7 | #include 8 | 9 | class TypeValue {}; 10 | 11 | void type(TypeValue &c) { 12 | std::cout << "passed value: TypeValue &c\n"; 13 | } 14 | 15 | void type(TypeValue &&c) { 16 | std::cout << "passed value: TypeValue &&c\n"; 17 | } 18 | 19 | void type(const TypeValue &c) { 20 | std::cout << "passed value: const TypeValue &c\n"; 21 | } 22 | 23 | template 24 | void pass(T&& value) { 25 | type(std::forward(value)); 26 | } 27 | 28 | int main() { 29 | TypeValue t1; 30 | const TypeValue t2; 31 | pass(t1);// calls & 32 | pass(t2);// calls const & 33 | pass(std::move(t1));// calls && 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /features/template_variadic/Makefile: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_variadic/Makefile.clang: -------------------------------------------------------------------------------- 1 | CXX=clang++-5.0 2 | CXX_FLAGS= -std=c++17 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_variadic/Makefile.clang9: -------------------------------------------------------------------------------- 1 | CXX=g++ 2 | CXX_FLAGS= -std=c++1z 3 | 4 | CPP_FILES := $(wildcard *.cpp) 5 | EXE_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.prog))) 6 | 7 | %.prog: %.cpp 8 | $(CXX) $(CXX_FLAGS) -o $@ $< 9 | 10 | all: $(EXE_FILES) 11 | 12 | clean: 13 | rm -f *.prog 14 | -------------------------------------------------------------------------------- /features/template_variadic/template_stringcat.cpp: -------------------------------------------------------------------------------- 1 | // variadic string concat function template 2 | // written by Jared Bruni 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | template 9 | void string_cat(std::string &s, const T &type) { 10 | std::ostringstream stream; 11 | stream << type; 12 | s += stream.str(); 13 | } 14 | 15 | template 16 | void string_cat(std::string &s,const T &obj,Args... args) { 17 | string_cat(s, obj); 18 | string_cat(s, args...); 19 | } 20 | 21 | int main() { 22 | std::string value; 23 | string_cat(value, "Hello ", "World: ", 100, " ", 200, " float: ", 200.5, "\n"); 24 | std::cout << value; 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /features/template_variadic/tup_test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | // Store pack in a tuple 5 | template 6 | class Test { 7 | public: 8 | std::tuple val; 9 | Test(Args... args) : val(args...) {} 10 | 11 | template 12 | void printElement() { 13 | std::cout << "Index at: " << V << " value = " << std::get(val) << "\n"; 14 | } 15 | }; 16 | 17 | int main() { 18 | Test v(0, 'a', 10); 19 | v.printElement<0>(); 20 | v.printElement<1>(); 21 | v.printElement<2>(); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_base.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class User { 4 | public: 5 | User(const std::string &xname, const std::string &xnumber) : name(xname), number(xnumber) { 6 | 7 | } 8 | std::string getName() const { return name; } 9 | std::string getNumber() const { return number; } 10 | 11 | private: 12 | std::string name, number; 13 | 14 | }; 15 | 16 | class OutputNumber { 17 | public: 18 | void printNumber(const User &u) { std::cout << u.getNumber() << "\n"; } 19 | }; 20 | 21 | class OutputName { 22 | public: 23 | void printName(const User &u) { std::cout << u.getName() << "\n"; } 24 | }; 25 | 26 | template 27 | class DB : public Bases... { 28 | public: 29 | 30 | }; 31 | 32 | int main() { 33 | User u("Jared", "1920858482"); 34 | 35 | DB p1; 36 | p1.printNumber(u); 37 | p1.printName(u); 38 | 39 | DB p2; 40 | p2.printName(u); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_construct.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | class Character : public Args... { 6 | public: 7 | Character(Args... args) : Args(args)... {} 8 | }; 9 | 10 | struct Point { 11 | double x,y,z; 12 | }; 13 | 14 | class User { 15 | std::string name; 16 | public: 17 | User(const std::string &n) : name(n) { 18 | std::cout << "Set name to: " << name << "\n"; 19 | } 20 | }; 21 | 22 | class Draw { 23 | public: 24 | Draw() = default; 25 | void drawAt(unsigned int screen_x, unsigned int screen_y) { 26 | // draw 27 | std::cout << "Draw command: " << screen_x << ":" << screen_y << "..\n"; 28 | } 29 | private: 30 | // character images 31 | }; 32 | 33 | int main() { 34 | Character hero({0, 0, 1},User("Jared"), Draw()); 35 | hero.drawAt(100, 100); 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_fold.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // using fold expression 4 | template 5 | auto addEmUp(T... x) { 6 | return (... + x); 7 | } 8 | 9 | int main() { 10 | int value = addEmUp(10, 20, 30)/3; 11 | std::cout << "10+20+30/3 = is: " << value << "\n"; 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_forward.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | void Print(const T &x) { 6 | std::cout << "forward: const T&: " << x << "\n"; 7 | } 8 | 9 | template 10 | void Print(T &x) { 11 | std::cout << "forward: T&: " << x << "\n"; 12 | } 13 | 14 | template 15 | void Print(T &&x) { 16 | std::cout << "forward: T&&: " << x << "\n"; 17 | } 18 | 19 | template 20 | void Test(Ts&&... xs) { 21 | Print(std::forward(xs)...); 22 | } 23 | 24 | int main() { 25 | int x = 10; 26 | Test(100); 27 | Test(x); 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_func.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | void echo(const T &value) { 5 | std::cout << value; 6 | } 7 | 8 | template 9 | void echo(const T &first, Types... args) { 10 | echo(first); 11 | echo(args...); 12 | } 13 | 14 | int main() { 15 | echo("Hello, ", " World! \n", 100, "+", 200, "=", 300, "\n"); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_indices.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | void print(const T &type) { 6 | std::cout << type << "\n"; 7 | } 8 | 9 | template 10 | void print(const T &type, Args... args) { 11 | print(type); 12 | print(args...); 13 | } 14 | 15 | template 16 | void PrintIndex(const Container &c, Index... index) { 17 | print(c[index]...); 18 | } 19 | 20 | int main() { 21 | std::vector v{"Hello, ", " World!", " Jared"}; 22 | PrintIndex(v, 0, 1, 2); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_nested.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Nested Variadic Template example 4 | 5 | */ 6 | 7 | #include 8 | 9 | template 10 | class Outer { 11 | public: 12 | template 13 | class Inner { 14 | public: 15 | template 16 | void TestOutput(T type) { 17 | std::cout << "Argument: " << type << "\n"; 18 | } 19 | template 20 | void TestOutput(T val, Type... type) { 21 | TestOutput(val); 22 | TestOutput(type...); 23 | } 24 | void PrintValues(Args... argx) { 25 | std::cout << sizeof...(argx) << " arguments.\n"; 26 | TestOutput(argx...); 27 | } 28 | void PrintValues() { 29 | std::cout << sizeof...(args) << " arguments.\n"; 30 | TestOutput(args...); 31 | } 32 | }; 33 | }; 34 | 35 | int main() { 36 | Outer::Inner<10, 'a', 25> c; 37 | c.PrintValues(12, 'b', 26); 38 | c.PrintValues(); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_sizeof.cpp: -------------------------------------------------------------------------------- 1 | // Will print out argument index for each variable argument 2 | // using sizeof... 3 | 4 | #include 5 | 6 | template 7 | void print(int len, const T &type) { 8 | std::cout << "argument index: " << len << " [" << type << "]\n"; 9 | } 10 | 11 | template 12 | void print(int len, const T &type, Args... args) { 13 | print(sizeof...(args), type); 14 | print(0, args...); 15 | } 16 | 17 | 18 | int main() { 19 | print(0x0, "Hello, ", "World!", " ", 100, "+", 255, "=", (100+255)); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_strcat.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | class StringCat { 6 | public: 7 | template 8 | void operator()(std::string &s, const T &type) { 9 | stream << type; 10 | s += stream.str(); 11 | stream.str(""); 12 | } 13 | 14 | template 15 | void operator()(std::string &s, const T &type, Args... args) { 16 | this->operator()(s, type); 17 | this->operator()(s, args...); 18 | } 19 | private: 20 | std::ostringstream stream; 21 | }; 22 | 23 | StringCat string_cat; 24 | 25 | 26 | int main() { 27 | std::string value1, value2 = "World!"; 28 | string_cat(value1, "Hello, ", value2, " ", 0xFF); 29 | std::cout << "String cat = " << value1 << "\n"; 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /features/template_variadic/variadic_vec_fold.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | template 6 | void insert_List(std::vector &v, Args... args) { 7 | (v.push_back(args), ...); 8 | } 9 | 10 | template 11 | void printVec(Iter start, Iter stop){ 12 | unsigned int index = 0; 13 | while(start != stop) { 14 | std::cout << index << ":\t" << *start << "\n"; 15 | start++; 16 | index++; 17 | } 18 | } 19 | 20 | int main() { 21 | std::vector values; 22 | insert_List(values, "Bruni, ", "Jared", "Hello, ", "World", "!"); 23 | printVec(values.begin(), values.end()); 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /features/variant/Makefile: -------------------------------------------------------------------------------- 1 | OBJ=$(patsubst %.cpp,%.o,$(wildcard *.cpp)) 2 | PROGRAM=var-ex 3 | CFLAGS= -std=c++17 4 | LDFLAGS= 5 | 6 | %.o: %.cpp 7 | $(CXX) $(CFLAGS) $< -c -o $@ 8 | 9 | $(PROGRAM): $(OBJ) 10 | $(CXX) -o $(PROGRAM) $(OBJ) $(LDFLAGS) 11 | 12 | all: $(PROGRAM) 13 | 14 | .PHONY: clean 15 | clean: 16 | rm -f $(PROGRAM) *.o 17 | -------------------------------------------------------------------------------- /features/variant/v.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using VType = std::variant; 7 | 8 | int main() { 9 | std::vector v{10, "Hello", 25}; 10 | for(auto &i : v) { 11 | std::visit([](const auto &obj) { 12 | std::cout << obj << "\n"; 13 | }, i); 14 | } 15 | 16 | VType v1; 17 | 18 | v1 = 42; 19 | 20 | std::cout << v1.index() << ": " << std::get(v1) << "\n"; 21 | 22 | v1 = "test"; 23 | 24 | std::cout << v1.index() << ": " << std::get(v1) << "\n"; 25 | 26 | 27 | return 0; 28 | } 29 | --------------------------------------------------------------------------------