├── .gitignore ├── LICENSE ├── Makefile ├── OpenCV └── 01.basic_skeleton │ ├── Makefile │ └── example01.cpp ├── README.md ├── SDL2 ├── 3card │ ├── 3card.cpp │ ├── 3card.hpp │ ├── Makefile │ ├── README.FIRST │ └── img │ │ ├── cardace.bmp │ │ ├── cardback.bmp │ │ ├── cardking.bmp │ │ └── font.ttf ├── opengl │ ├── cube │ │ ├── Makefile │ │ ├── Makefile.mac │ │ ├── f.frag │ │ ├── gltest.cpp │ │ ├── v.vert │ │ └── vmath.h │ └── simple │ │ ├── Makefile │ │ ├── f.frag │ │ ├── gltest.cpp │ │ └── v.vert └── sdl2_test │ ├── Makefile │ ├── Makefile.sdl │ ├── SDL2_test.cpp │ ├── SDL2_test2.cpp │ ├── ball.bmp │ ├── paddle.bmp │ └── pong.cpp ├── UNIX ├── Makefile ├── Makefile.linux ├── README.md ├── attr │ ├── Makefile │ └── attr-list.cpp ├── directory │ ├── Makefile │ ├── dir-find.cpp │ └── dir-test.cpp ├── environment │ ├── Makefile │ └── env.cpp ├── getopt │ ├── Makefile │ ├── getopt.cpp │ └── getopt2.cpp ├── info │ ├── Makefile │ ├── stat.cpp │ └── uname.cpp ├── io │ ├── Makefile │ ├── io-read.cpp │ ├── io-readwrite.cpp │ ├── io-redirect.cpp │ ├── poll.cpp │ └── signal-io.cpp ├── ipc │ ├── Makefile │ ├── Makefile.linux │ ├── fifo-read.cpp │ ├── fifo-write.cpp │ ├── fifo.hpp │ ├── mmap.cpp │ ├── mqueue-create.cpp │ ├── mqueue-recv.cpp │ ├── mqueue-send.cpp │ ├── mqueue-unlink.cpp │ ├── pipe.cpp │ ├── popen.cpp │ ├── posix-sem-create.cpp │ ├── posix-sem-post.cpp │ ├── posix-sem-thread.cpp │ ├── posix-sem-unlink.cpp │ ├── posix-sem-wait.cpp │ ├── posix-shm-create.cpp │ ├── posix-shm-read.cpp │ ├── posix-shm-unlink.cpp │ ├── posix-shm-write.cpp │ ├── s.txt │ ├── sysv_sem_binary.hpp │ ├── sysv_sm.hpp │ ├── sysv_sm_read.cpp │ ├── sysv_sm_write.cpp │ └── sysvmsgq_ls.cpp ├── login │ ├── Makefile │ └── login.cpp ├── memory │ ├── Makefile │ ├── alloca-test.cpp │ ├── memory.cpp │ └── realloc.cpp ├── network │ ├── Makefile │ ├── af_unix-stream-client.cpp │ ├── af_unix-stream-server.cpp │ ├── listtest.cpp │ ├── socket.cpp │ ├── socket.hpp │ ├── socktest.cpp │ ├── socktest2.cpp │ ├── unix-udp-cli.cpp │ └── unix-udp-srv.cpp ├── notify │ ├── Makefile.linux │ └── inotify-test.cpp ├── proc │ ├── Makefile.linux │ └── procinfo.cpp ├── process │ ├── Makefile │ ├── execve.cpp │ ├── fork.cpp │ ├── forktest.cpp │ ├── manyfork.cpp │ ├── system.cpp │ └── vfork.cpp ├── pseudo │ ├── Makefile │ ├── pterm.cpp │ ├── pterm.hpp │ └── terminal.cpp ├── pthread │ ├── Makefile │ ├── pthread-cancel.cpp │ ├── pthread-cond.cpp │ ├── pthread-mutex.cpp │ ├── pthread-once.cpp │ ├── pthread-self.cpp │ └── pthread-test.cpp ├── sched │ ├── Makefile.linux │ ├── README │ ├── get.cpp │ └── set.cpp ├── setjmp │ ├── Makefile │ └── setjmptest.cpp ├── shared │ ├── Makefile │ ├── Makefile.linux │ ├── dynamic_init │ │ ├── Makefile │ │ ├── Makefile.linux │ │ ├── header.h │ │ ├── lib.cpp │ │ └── prog.cpp │ ├── dynamic_load │ │ ├── Makefile │ │ ├── Makefile.linux │ │ ├── header.h │ │ ├── lib.cpp │ │ └── prog.cpp │ ├── simple_lib │ │ ├── Makefile │ │ ├── Makefile.linux │ │ ├── README │ │ ├── header.h │ │ ├── lib.cpp │ │ └── prog.cpp │ └── simple_lib2 │ │ ├── Makefile │ │ ├── Makefile.linux │ │ ├── README │ │ ├── header.h │ │ ├── lib.cpp │ │ └── prog.cpp ├── signal │ ├── Makefile │ ├── isprocess.cpp │ ├── sigaction-test.cpp │ ├── signal-test-send.cpp │ └── signal-test.cpp ├── socket_class │ ├── socket.cpp │ └── socket.hpp ├── syslog │ ├── Makefile │ └── log.cpp ├── time │ ├── Makefile │ ├── gettickcount.cpp │ └── gettime.cpp ├── timer │ ├── Makefile │ ├── alarm.cpp │ ├── nanosleep.cpp │ ├── nanosleep_wait.cpp │ └── timer.cpp └── user │ ├── Makefile │ ├── Makefile.linux │ ├── crypt.cpp │ ├── gen_pass │ ├── Makefile │ ├── Makefile.linux │ └── gen_pass.cpp │ └── users.cpp ├── algorithm ├── Makefile ├── find_if.cpp ├── for_each.cpp ├── sort.cpp └── transform.cpp ├── allocator ├── Makefile └── al.cc ├── array ├── Makefile ├── ar.cc └── ar2.cc ├── arraybyte ├── Makefile ├── arraybyte.hpp └── main.cpp ├── assert ├── Makefile └── main.cpp ├── auto ├── Makefile ├── autotest.cc └── autotest2.cpp ├── bin2cpp_memfile ├── Makefile ├── README.md ├── bin2cpp.cpp ├── extract_image.cpp ├── image_res │ ├── floyd.cpp │ └── floyd.h ├── memfile.hpp ├── memfile_demo.cpp └── resource │ ├── resource.cpp │ └── resource.h ├── bin_to_array ├── Makefile ├── bin2cpp.cpp ├── bin2cpp.cpp.cpp ├── bin2cpp.cpp.h └── test │ ├── Makefile │ ├── test.cpp │ ├── test.cpp.cpp │ └── test.cpp.h ├── bitmask ├── Makefile └── mask.cpp ├── bitset ├── Makefile └── bitset_test.cc ├── boost └── asio │ ├── async_server │ ├── Makefile │ ├── client.cpp │ └── server.cpp │ ├── download │ ├── Makefile │ └── download.cpp │ ├── ex1 │ ├── Makefile │ ├── filesend.cpp │ ├── filesend.hpp │ ├── main.cpp │ └── server.cpp │ ├── filesend │ ├── Makefile │ ├── filesend.cpp │ ├── filesend.hpp │ ├── main.cpp │ └── server.cpp │ ├── fileserv │ ├── Makefile │ └── file-server.cpp │ └── whiteboard │ ├── Makefile │ ├── WhiteBoard.app.zip │ └── whiteboard.cpp ├── calculator ├── Makefile ├── README ├── lexer.h └── main.cpp ├── cast ├── Makefile └── casttest.cc ├── cgi ├── Makefile ├── sourcefile.cpp └── tokenize-c++ │ ├── Makefile │ ├── index.html │ ├── lexer.hpp │ ├── sourcefile.cpp │ ├── test.html │ └── test.txt ├── chrono ├── Makefile ├── looptest.cc ├── scoped_t.cc └── timetest.cc ├── compile_test ├── Makefile ├── Makefile.mingw ├── compile-test ├── compile-test.cpp └── compile-test.exe ├── compress_code ├── Makefile ├── compress-code ├── format.cpp ├── lexer.hpp ├── main.cpp └── test.html ├── constexpr ├── Makefile ├── constexpr-test.cc ├── constexpr.cc └── constexpr_example.cpp ├── databyte ├── Makefile ├── databytes.hpp └── main.cpp ├── db ├── Makefile ├── db.cpp └── phone.hpp ├── download ├── Makefile ├── main.cpp └── socket.hpp ├── enum ├── Makefile ├── enum.cc └── enum_class.cpp ├── finally ├── Makefile └── finally.cc ├── find ├── Makefile └── find.cpp ├── friend ├── Makefile └── friend_test.cc ├── fstream ├── Makefile ├── readwrite.cc └── textoutput.cc ├── function_objects ├── Makefile ├── func1.cpp └── func2.cpp ├── function_syntax ├── Makefile ├── function_syntax.cc └── test1.cc ├── generic ├── Makefile ├── temp1.cc └── temp2.cc ├── hash ├── Makefile ├── hash1.cpp ├── hash2.cpp └── hash3.cpp ├── hero ├── Makefile ├── hero.hpp └── main.cc ├── idea ├── Makefile └── love.cpp ├── init ├── Makefile ├── init_list.cc └── init_test.cpp ├── iterator ├── Makefile ├── it.cpp ├── it2.cpp └── it3.cpp ├── join ├── Makefile ├── join.hpp └── main.cpp ├── karma.cpp ├── lambda ├── Makefile ├── lambda-test.cpp ├── lambda.cc ├── lambda2.cc ├── lambda_capture.cc ├── main.cc ├── source.cc └── test.cc ├── lexer ├── Makefile ├── lexer.hpp ├── lexer.hpp.html ├── main.cpp ├── main.cpp.html ├── mxl-test.cpp ├── mxl.hpp ├── program-test1.cpp ├── program-test2.cpp └── tags.mxl ├── linesort ├── Makefile ├── code.cpp ├── code.hpp ├── func_clear.cpp ├── func_convert.cpp ├── func_display.cpp ├── func_list.cpp ├── func_open.cpp ├── func_remove.cpp ├── func_save.cpp ├── function.cpp ├── function.hpp ├── lexer.cpp ├── lexer.hpp └── main.cpp ├── linkedlist ├── Makefile └── list.cpp ├── list_to_array ├── Makefile ├── list_to_array.cpp └── test.txt ├── m3ugen ├── Makefile ├── m3u.hpp └── main.cc ├── main ├── Makefile └── main.cpp ├── member ├── Makefile └── memberdecl.cc ├── member_fun_pointer ├── Makefile └── main.cpp ├── memfile ├── Makefile ├── main.cpp ├── memfile.hpp └── memfile_hpp.hpp ├── misc ├── Makefile └── forward.cpp ├── move ├── Makefile ├── move_test.cc ├── move_test2.cc └── move_test3.cc ├── mutable ├── Makefile └── mut.cc ├── namespace ├── Makefile ├── inline_namespace_ex.cc ├── namespace2.cpp └── namespace3.cpp ├── operator ├── Makefile ├── default.cc ├── equal.cpp ├── operator.cc └── plus.cc ├── operator_new ├── Makefile └── new.cpp ├── override ├── Makefile ├── override_test.cc ├── ptr │ ├── Makefile │ └── main.cpp └── virtual_base.cc ├── persist ├── Makefile ├── ioadd.hpp ├── persist-vector-main.cpp ├── persist-vector.hpp ├── persist.cc ├── persist.hpp ├── scores.hpp └── socket.hpp ├── pool ├── Makefile ├── driver.cc └── memory.hpp ├── printdir ├── Makefile └── printdir.cpp ├── random ├── Makefile ├── r.cc ├── randtest ├── shuffle.cc └── shuffle2.cc ├── rar_extract ├── Makefile ├── unrar_extract ├── unrar_extract.cpp └── unrar_extract.exe ├── readfast_textscroll ├── Makefile ├── blog.txt ├── lexer.hpp ├── linescroll ├── linescroll.cpp ├── plaintext_scroll ├── scroll.cpp ├── test.txt ├── textscroll └── textscroll.cpp ├── regex ├── Makefile ├── regex.cpp └── regex_test.cc ├── rename_files ├── Makefile └── file_rename.cc ├── replace ├── Makefile ├── main.cpp └── replace.hpp ├── rotate ├── Makefile └── ror_rol.cpp ├── rvalue ├── Makefile ├── rvalue1.cpp ├── rvalue2.cpp ├── rvalue3.cpp ├── rvalue4.cpp └── rvalue5.cpp ├── sdl2_test ├── Makefile ├── SDL2_test.cpp ├── SDL2_test2.cpp ├── ball.bmp ├── paddle.bmp └── pong.cpp ├── set ├── Makefile ├── set-test └── set.cpp ├── shared ├── Makefile ├── sharedtest.cpp └── sharedtest2.cpp ├── smart_pointer ├── Makefile ├── smart.cpp └── unique.cc ├── sort ├── Makefile ├── sort1.cpp └── sort2.cpp ├── sort_files ├── Makefile ├── main.cpp └── sfile.hpp ├── static ├── Makefile ├── static1.cpp ├── static2.cpp └── static_main.h ├── stopwatch ├── Makefile ├── looptest.cpp ├── main.cpp ├── movetest.cpp ├── readtest.cpp ├── stopwatch.hpp └── string-test.cpp ├── stream_insert_iterators ├── Makefile ├── insert_iterator.cpp └── stream_iterator.cpp ├── stringstream ├── Makefile ├── iss.cc ├── iss2.cc └── ss.cc ├── symbol_table ├── Makefile └── symbol_table.cc ├── templates ├── Makefile ├── template-class.cpp ├── template-class2.cpp ├── template-class3.cpp ├── template-function.cpp ├── template-inst.cpp ├── template-pointer.cpp ├── template-spec.cpp ├── template-template.cpp ├── template-type.cpp └── template-union.cpp ├── test ├── Makefile ├── static_assert_test.cc ├── temp_test.cc ├── temp_test2.cc ├── test.cc ├── test2.cc └── typearr.cc ├── thought.cc ├── thread ├── Makefile ├── async_test.cc ├── async_test2.cc ├── async_test3.cc ├── async_test4.cpp ├── atomic.cpp ├── detach.cpp ├── promise.cc └── thread_test.cc ├── tilemap ├── Makefile ├── TileMap2 │ ├── Makefile │ ├── TileMap.h │ └── main.cpp ├── Tilemap.h ├── main.cpp ├── newtilemap │ ├── .cproject │ ├── .project │ └── newtilemap │ │ ├── newtilemap.xcodeproj │ │ ├── project.pbxproj │ │ ├── project.xcworkspace │ │ │ ├── contents.xcworkspacedata │ │ │ └── xcuserdata │ │ │ │ └── jared.xcuserdatad │ │ │ │ └── UserInterfaceState.xcuserstate │ │ └── xcuserdata │ │ │ └── jared.xcuserdatad │ │ │ └── xcschemes │ │ │ ├── newtilemap.xcscheme │ │ │ └── xcschememanagement.plist │ │ └── newtilemap │ │ ├── main.cpp │ │ ├── newtilemap.1 │ │ ├── sdltest │ │ ├── Makefile │ │ └── test.cpp │ │ └── tile.hpp └── test ├── tokenize ├── Makefile ├── collect_tokens.cpp ├── lexer.hpp ├── parse.cpp └── tokenize.cpp ├── transfer ├── Makefile ├── socket.hpp └── transfer.cc ├── trim_lines ├── Makefile ├── triml ├── triml.cpp └── triml.cpp.txt ├── try ├── Makefile ├── try.cc └── try2.cc ├── tuple ├── Makefile └── t.cc ├── typeid ├── Makefile ├── typeid_test.cc └── typeid_test2.cpp ├── unordered_map ├── Makefile ├── print_recursive.cc └── unordered_map_test.cc ├── variadic ├── Makefile ├── v.cc └── v2.cc └── vector ├── Makefile ├── em.cc └── persist_vector.cc /.gitignore: -------------------------------------------------------------------------------- 1 | *DS_Store 2 | -------------------------------------------------------------------------------- /OpenCV/01.basic_skeleton/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | CV_CFLAGS=`pkg-config opencv --cflags` 3 | CV_LDFLAGS=`pkg-config opencv --libs` 4 | PROGRAM=example01 5 | 6 | $(PROGRAM): $(PROGRAM).cpp 7 | $(CXX) $(CXX_FLAGS) $(CV_CFLAGS) $(PROGRAM).cpp -o $(PROGRAM) $(CV_LDFLAGS) 8 | clean: 9 | rm -f $(PROGRAM) 10 | 11 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Jared Bruni's C++11 Examples 2 | 3 | This collection is my way of navigating through, and reinforcing my understanding of, C++11's new functionalities. I no longer plan to write a repository for C++14 as I have one for C++17. 4 | 5 | The primary purpose of these examples is to showcase specific C++11 features rather than to provide practical utility. However, a few examples are designed to address real tasks, such as creating m3u playlists or generating HTML for CGI applications. 6 | 7 | Included among the examples is a calculator that parses expressions, reminiscent of the one featured in "The C++ Programming Language" 4th Edition. 8 | 9 | ## Compilation Instructions: 10 | 11 | ### For MacOS X: 12 | 13 | ``` 14 | $ make 15 | ``` 16 | 17 | ### For Linux: 18 | 19 | ``` 20 | $ make -f Makefile.linux 21 | ``` 22 | 23 | ## Compilation Note: 24 | Ensure your compiler is C++11 compatible. When using clang, for instance, compile a source file with: 25 | 26 | ``` 27 | clang++ -std=c++11 sourcefile.cc -o sourcefile 28 | ``` 29 | 30 | On Linux, opt for libstdc++ and use g++ version 4.8 or newer. Compiling any program requires just a single line: 31 | 32 | ``` 33 | g++ -std=c++11 sourcefile.cc -o sourcefile 34 | ``` 35 | 36 | - Jared Bruni 37 | -------------------------------------------------------------------------------- /SDL2/3card/Makefile: -------------------------------------------------------------------------------- 1 | ### be sure to set SDL_PATH to the path of SDL2 2 | 3 | CXX=c++ 4 | SDL_PATH= 5 | CPP_FLAGS= -std=c++11 -stdlib=libc++ -Wall 6 | CXX_FLAGS= `sdl2-config --cflags` 7 | LD_FLAGS= `freetype-config --libs` `sdl2-config --static-libs` -lSDL2_ttf 8 | 9 | all: 3card-prog 10 | 11 | 3card-prog: 3card.cpp 12 | $(CXX) $(CPP_FLAGS) 3card.cpp -c -o 3card.o $(CXX_FLAGS) 13 | $(CXX) $(CPP_FLAGS) 3card.o -o 3card-prog $(LD_FLAGS) 14 | clean: 15 | rm -f 3card-prog *.o 16 | -------------------------------------------------------------------------------- /SDL2/3card/README.FIRST: -------------------------------------------------------------------------------- 1 | Be sure to Set the path to your install location of SDL2 and SDL2_ttf 2 | in Makefile SDL_PATH variable 3 | -------------------------------------------------------------------------------- /SDL2/3card/img/cardace.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/SDL2/3card/img/cardace.bmp -------------------------------------------------------------------------------- /SDL2/3card/img/cardback.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/SDL2/3card/img/cardback.bmp -------------------------------------------------------------------------------- /SDL2/3card/img/cardking.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/SDL2/3card/img/cardking.bmp -------------------------------------------------------------------------------- /SDL2/3card/img/font.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/SDL2/3card/img/font.ttf -------------------------------------------------------------------------------- /SDL2/opengl/cube/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXXFLAGS= -I/usr/include -I/usr/local/include -std=c++11 -Wall `sdl2-config --cflags` 3 | LDFLAGS= `sdl2-config --static-libs` -lGL -lGLU -lGLEW 4 | 5 | all: gltest 6 | 7 | gltest: 8 | $(CXX) gltest.cpp -o gltest $(CXXFLAGS) $(LDFLAGS) 9 | clean: 10 | rm -f gltest 11 | -------------------------------------------------------------------------------- /SDL2/opengl/cube/Makefile.mac: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXXFLAGS= -I/usr/include -I/usr/local/include -std=c++11 -Wall `sdl2-config --cflags` 3 | LDFLAGS= `sdl2-config --static-libs` -framework OpenGL -lGLEW 4 | 5 | all: gltest 6 | 7 | gltest: 8 | $(CXX) gltest.cpp -o gltest $(CXXFLAGS) $(LDFLAGS) 9 | clean: 10 | rm -f gltest 11 | -------------------------------------------------------------------------------- /SDL2/opengl/cube/f.frag: -------------------------------------------------------------------------------- 1 | #version 410 core 2 | 3 | out vec4 color; 4 | in VS_OUT { 5 | vec4 color; 6 | } fs_in; 7 | 8 | void main(void) 9 | { 10 | color = fs_in.color; 11 | } -------------------------------------------------------------------------------- /SDL2/opengl/cube/v.vert: -------------------------------------------------------------------------------- 1 | #version 410 core 2 | 3 | in vec4 position; 4 | 5 | out VS_OUT { 6 | vec4 color; 7 | } vs_out; 8 | 9 | uniform mat4 mv_matrix; 10 | uniform mat4 proj_matrix; 11 | void main(void) 12 | { 13 | gl_Position = proj_matrix * mv_matrix * position; 14 | vs_out.color = position * 2.0 + vec4(0.5, 0.5, 0.5, 0.0); 15 | } 16 | -------------------------------------------------------------------------------- /SDL2/opengl/simple/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXXFLAGS= -I/usr/include -std=c++11 -Wall `sdl2-config --cflags` 3 | LDFLAGS= `sdl2-config --static-libs` /usr/lib/libGLEW.a 4 | 5 | all: gltest 6 | 7 | gltest: 8 | $(CXX) gltest.cpp -o gltest $(CXXFLAGS) $(LDFLAGS) 9 | clean: 10 | rm -f gltest 11 | -------------------------------------------------------------------------------- /SDL2/opengl/simple/f.frag: -------------------------------------------------------------------------------- 1 | #version 410 core 2 | 3 | out vec4 fColor; 4 | void 5 | 6 | main() { 7 | 8 | fColor = vec4(0.0, 0.0, 1.0, 1.0); 9 | 10 | } 11 | 12 | -------------------------------------------------------------------------------- /SDL2/opengl/simple/v.vert: -------------------------------------------------------------------------------- 1 | #version 410 core 2 | layout(location = 0) in vec4 vPosition; 3 | void 4 | main() { 5 | gl_Position = vPosition; 6 | } 7 | 8 | 9 | -------------------------------------------------------------------------------- /SDL2/sdl2_test/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | SDL_PATH=/opt/local/sdl 3 | 4 | FLAGS=-std=c++11 `sdl2-config --cflags --libs` -framework OpenGL 5 | all: sdl2-test sdl2-test2 pong-test 6 | 7 | sdl2-test: 8 | $(CXX) SDL2_test.cpp -o sdl2-test $(FLAGS) 9 | sdl2-test2: 10 | $(CXX) SDL2_test2.cpp -o sdl2-test2 $(FLAGS) 11 | pong-test: 12 | $(CXX) pong.cpp -o pong-test $(FLAGS) 13 | clean: 14 | rm -f sdl2-test sdl2-test2 pong-test 15 | -------------------------------------------------------------------------------- /SDL2/sdl2_test/Makefile.sdl: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | SDL_PATH=/opt/local/sdl 3 | 4 | FLAGS=-std=c++11 `sdl2-config --cflags --libs` -lGL 5 | all: 6 | $(CXX) SDL2_test.cpp -o sdl2-test $(FLAGS) 7 | $(CXX) SDL2_test2.cpp -o sdl2-test2 $(FLAGS) 8 | $(CXX) pong.cpp -o pong-test $(FLAGS) 9 | clean: 10 | rm -f sdl2-test sdl2-test2 pong-test 11 | -------------------------------------------------------------------------------- /SDL2/sdl2_test/ball.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/SDL2/sdl2_test/ball.bmp -------------------------------------------------------------------------------- /SDL2/sdl2_test/paddle.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/SDL2/sdl2_test/paddle.bmp -------------------------------------------------------------------------------- /UNIX/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | make -C attr/ 3 | make -C directory/ 4 | make -C environment/ 5 | make -C process/ 6 | make -C pseudo/ 7 | make -C getopt/ 8 | make -C info/ 9 | make -C io/ 10 | make -C ipc/ 11 | make -C login/ 12 | make -C memory/ 13 | make -C network/ 14 | make -C pthread/ 15 | make -C setjmp/ 16 | make -C shared/ 17 | make -C signal/ 18 | make -C syslog/ 19 | make -C time/ 20 | make -C timer/ 21 | make -C user/ 22 | clean: 23 | make -C attr/ clean 24 | make -C directory/ clean 25 | make -C environment/ clean 26 | make -C process/ clean 27 | make -C pseudo/ clean 28 | make -C info/ clean 29 | make -C getopt/ clean 30 | make -C io/ clean 31 | make -C ipc/ clean 32 | make -C login/ clean 33 | make -C memory/ clean 34 | make -C network/ clean 35 | make -C pthread/ clean 36 | make -C setjmp/ clean 37 | make -C shared/ clean 38 | make -C signal/ clean 39 | make -C syslog/ clean 40 | make -C time/ clean 41 | make -C timer/ clean 42 | make -C user/ clean 43 | -------------------------------------------------------------------------------- /UNIX/attr/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: attr-list 4 | 5 | attr-list: attr-list.cpp 6 | $(CXX) $(CXX_FLAGS) attr-list.cpp -o attr-list 7 | clean: 8 | rm -f attr-list 9 | -------------------------------------------------------------------------------- /UNIX/directory/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: dir-test dir-find 4 | 5 | 6 | dir-test: dir-test.cpp 7 | $(CXX) $(CXX_FLAGS) dir-test.cpp -o dir-test 8 | 9 | dir-find: dir-find.cpp 10 | $(CXX) $(CXX_FLAGS) dir-find.cpp -o dir-find 11 | 12 | clean: 13 | rm -f dir-test dir-find 14 | -------------------------------------------------------------------------------- /UNIX/directory/dir-test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void printDir(std::string name) { 8 | DIR *dir = opendir(name.c_str()); 9 | if(dir == NULL) { 10 | std::cerr << "Error could not open directory..\n"; 11 | return; 12 | } 13 | dirent *file_info; 14 | while((file_info = readdir(dir)) != 0) { 15 | std::string f_info = file_info->d_name; 16 | if(f_info == "." || f_info == "..") continue; 17 | std::string fullpath=name+"/"+f_info; 18 | struct stat s; 19 | stat(fullpath.c_str(), &s); 20 | if(S_ISDIR(s.st_mode)) { 21 | if(f_info.length()>0 && f_info[0] != '.') 22 | printDir(name+"/"+f_info); 23 | continue; 24 | } 25 | if(f_info.length()>0 && f_info[0] != '.') 26 | std::cout << fullpath << "\n"; 27 | } 28 | closedir(dir); 29 | } 30 | 31 | 32 | int main(int argc, char **argv) { 33 | if(argc != 2) { 34 | std::cerr << "Error requires one argument directory to print..\n"; 35 | std::cerr << argv[0] << " directory\n"; 36 | exit(EXIT_FAILURE); 37 | } 38 | 39 | printDir(argv[1]); 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /UNIX/environment/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: env-test 4 | 5 | env-test: env.cpp 6 | $(CXX) $(CXX_FLAGS) env.cpp -o env-test 7 | 8 | clean: 9 | rm -f env-test 10 | -------------------------------------------------------------------------------- /UNIX/environment/env.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | 6 | 7 | std::cout << "Path: " << getenv("PATH") << "\n"; 8 | 9 | setenv("VALUE", "ONE VALUE", 0); 10 | 11 | std::cout << "Value: " << getenv("VALUE") << "\n"; 12 | 13 | 14 | return EXIT_SUCCESS; 15 | } 16 | -------------------------------------------------------------------------------- /UNIX/getopt/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: getopt-test getopt-test2 4 | 5 | getopt-test: getopt.cpp 6 | $(CXX) $(CXX_FLAGS) getopt.cpp -o getopt-test 7 | getopt-test2: getopt2.cpp 8 | $(CXX) $(CXX_FLAGS) getopt2.cpp -o getopt-test2 9 | clean: 10 | rm -f getopt-test getopt-test2 11 | -------------------------------------------------------------------------------- /UNIX/getopt/getopt.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | if(argc > 1) { 6 | int opt; 7 | std::cout << "Argument options...\n"; 8 | while((opt = getopt(argc, argv, "cxi:")) != -1) { 9 | switch(opt) { 10 | case 'c': 11 | std::cout << "c option\n"; 12 | break; 13 | case 'x': 14 | std::cout << "x option\n"; 15 | break; 16 | case 'i': 17 | std::cout << "i option: " << optarg << "\n"; 18 | break; 19 | } 20 | } 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /UNIX/getopt/getopt2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Program { 5 | public: 6 | Program(unsigned int c) : count(c) {} 7 | void run(); 8 | private: 9 | unsigned int count; 10 | }; 11 | 12 | void Program::run() { 13 | for(unsigned int i = 0; i < count; ++i) { 14 | std::cout << "Hello World with getopt!.\n"; 15 | } 16 | } 17 | 18 | int main(int argc, char **argv) { 19 | if(argc > 1) { 20 | int opt; 21 | unsigned int counter = 0; 22 | while((opt = getopt(argc, argv, "c:")) != -1) { 23 | switch(opt) { 24 | case 'c': 25 | counter = atoi(optarg); 26 | if(counter == 0) { 27 | std::cerr << "Error requires loop count...\n"; 28 | exit(EXIT_FAILURE); 29 | } 30 | break; 31 | default: 32 | std::cout << " use -c counter\n"; 33 | exit(0); 34 | break; 35 | } 36 | } 37 | Program program(counter); 38 | program.run(); 39 | } else { 40 | std::cerr << "use: " << argv[0] << " -c counter\n"; 41 | } 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /UNIX/info/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: uname-info stat-info 4 | 5 | uname-info: uname.cpp 6 | $(CXX) $(CXX_FLAGS) uname.cpp -o uname-info 7 | 8 | stat-info: stat.cpp 9 | $(CXX) $(CXX_FLAGS) stat.cpp -o stat-info 10 | 11 | clean: 12 | rm -f uname-info stat-info 13 | -------------------------------------------------------------------------------- /UNIX/info/uname.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | int main() { 8 | 9 | utsname uts; 10 | 11 | if(uname(&uts) == -1) { 12 | std::cerr << "Error on uname: " << strerror(errno) << "\n"; 13 | exit(EXIT_FAILURE); 14 | } 15 | 16 | std::cout << "Node: " << uts.nodename << "\nSystem: " << uts.sysname << "\nRelease: " << uts.release << "\nVersion: " << uts.version << "\nMachine: " << uts.machine << "\n"; 17 | 18 | return EXIT_SUCCESS; 19 | } 20 | -------------------------------------------------------------------------------- /UNIX/io/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 -Wall 2 | 3 | all: read-test rdwr-test redir-test poll-test signal-io 4 | 5 | rdwr-test: io-readwrite.cpp 6 | $(CXX) $(CXX_FLAGS) io-readwrite.cpp -o rdwr-test 7 | 8 | read-test: io-read.cpp 9 | $(CXX) $(CXX_FLAGS) io-read.cpp -o read-test 10 | 11 | redir-test: io-redirect.cpp 12 | $(CXX) $(CXX_FLAGS) io-redirect.cpp -o redir-test 13 | 14 | poll-test: poll.cpp 15 | $(CXX) $(CXX_FLAGS) poll.cpp -o poll-test 16 | 17 | signal-io: signal-io.cpp 18 | $(CXX) $(CXX_FLAGS) signal-io.cpp -o signal-io-test 19 | 20 | 21 | clean: 22 | rm -f read-test rdwr-test redir-test poll-test signal-io-test 23 | 24 | -------------------------------------------------------------------------------- /UNIX/io/io-read.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | 7 | if(argc != 2) { 8 | std::cout << "Requires one argument file to output..\n"; 9 | return 0; 10 | } 11 | 12 | int fd = open(argv[1], O_RDONLY); 13 | 14 | if(fd == -1) { 15 | std::cerr << "Error opening file: " << argv[1] << "\n"; 16 | return 0; 17 | } 18 | 19 | ssize_t bytesRead = 0; 20 | 21 | char buf [1024]; 22 | 23 | while((bytesRead = read(fd, buf, 1024)) > 0) { 24 | if(write(STDOUT_FILENO, buf, bytesRead) != bytesRead) { 25 | std::cerr << "Couldn't write whole buffer..\n"; 26 | } 27 | } 28 | close(fd); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /UNIX/io/io-readwrite.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int main(int argc, char **argv) { 7 | 8 | if(argc != 3) { 9 | std::cerr << "Error requires two arguments input output\n"; 10 | return 0; 11 | } 12 | 13 | int rd_fd = open(argv[1], O_RDONLY); 14 | 15 | if(rd_fd == -1) { 16 | std::cerr << "Error opening input file: " << argv[1] << "\n"; 17 | return 0; 18 | } 19 | 20 | int wr_fd = open(argv[2], O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); 21 | 22 | if(wr_fd == -1) { 23 | std::cerr << "Error opening output file: " << argv[2] << "\n"; 24 | return 0; 25 | } 26 | 27 | ssize_t readBytes = 0; 28 | char buf[1024]; 29 | 30 | while((readBytes = read(rd_fd, buf, 1024)) > 0) { 31 | if(write(wr_fd, buf, readBytes) != readBytes) { 32 | std::cerr << "Error couldn't write all bytes..\n"; 33 | } 34 | } 35 | 36 | close(wr_fd); 37 | close(rd_fd); 38 | 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /UNIX/io/io-redirect.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char **argv) { 6 | 7 | 8 | if(argc != 3) { 9 | std::cerr << "Error program requires two arguments.\n" << argv[0] << " stdout stderr\n"; 10 | return 0; 11 | } 12 | 13 | freopen(argv[1], "w", stdout); 14 | freopen(argv[2], "w", stderr); 15 | system("cat ./io-redirect.cpp"); 16 | fclose(stdout); 17 | fclose(stderr); 18 | 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /UNIX/ipc/fifo.hpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 44 3 | */ 4 | 5 | #ifndef __FIFO__H__ 6 | #define __FIFO__H__ 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | static const char *SERVER_NAME = "/tmp/seqnum_server"; 14 | static const char *FIFO_NAME_TEMPLATE = "/tmp/seqnum_cl"; 15 | static const unsigned int FIFO_NAME_LEN = sizeof(FIFO_NAME_TEMPLATE)+25; 16 | 17 | struct Request { 18 | pid_t id; 19 | int len; 20 | }; 21 | 22 | struct Response { 23 | int len; 24 | }; 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /UNIX/ipc/mqueue-create.cpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 53 3 | */ 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int main(int argc, char **argv) { 12 | mqd_t mqd; 13 | mode_t perms; 14 | mq_attr attr; 15 | int flags; 16 | attr.mq_maxmsg = 10; 17 | attr.mq_msgsize = 2048; 18 | flags = O_RDWR | O_CREAT; 19 | perms = S_IRUSR | S_IWUSR; 20 | mqd = mq_open(argv[1], flags, perms, &attr); 21 | if(mqd == (mqd_t) -1) { 22 | std::cerr << "Error creating queue.\n" << strerror(errno) << "\n"; 23 | exit(EXIT_FAILURE); 24 | } 25 | return EXIT_SUCCESS; 26 | } 27 | -------------------------------------------------------------------------------- /UNIX/ipc/mqueue-send.cpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 52 3 | */ 4 | #include 5 | #include 6 | #include 7 | 8 | int main(int argc, char **argv) { 9 | 10 | if(argc != 3) { 11 | std::cerr << "Error requires two arguments\n" << argv[0] << "path prority\n"; 12 | exit(EXIT_FAILURE); 13 | } 14 | 15 | int prio = atoi(argv[2]); 16 | 17 | mqd_t mqd; 18 | mqd = mq_open(argv[1], O_CREAT | O_WRONLY); 19 | if(mqd == (mqd_t) -1) { 20 | std::cerr << "Error failed to open queue.\n"; 21 | exit(EXIT_FAILURE); 22 | } 23 | 24 | char buffer[1024]; 25 | std::cin >> buffer; 26 | 27 | if(mq_send(mqd, buffer, strlen(buffer), prio) == -1) { 28 | std::cerr << "Error sending message..\n"; 29 | } 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /UNIX/ipc/mqueue-unlink.cpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 52 3 | */ 4 | #include 5 | #include 6 | 7 | int main(int argc, char **argv) { 8 | if(argc != 2) { 9 | std::cerr << "Error argument not given.\n" << argv[0] << " queue\n"; 10 | exit(EXIT_FAILURE); 11 | } 12 | if(mq_unlink(argv[1]) == -1) { 13 | std::cerr << "Could not unlink: " << argv[1] << "\n"; 14 | exit(EXIT_FAILURE); 15 | } 16 | return EXIT_SUCCESS; 17 | } 18 | -------------------------------------------------------------------------------- /UNIX/ipc/popen.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | 6 | FILE *fptr = popen("ps -A", "r"); 7 | 8 | if(!fptr) { 9 | std::cerr << "Error opening program: ps\n"; 10 | exit(EXIT_FAILURE); 11 | } 12 | 13 | while(!feof(fptr)) { 14 | char buf[1024]; 15 | ssize_t r = fread(buf, 1, 1024, fptr); 16 | if(r > 0) { 17 | buf[r] = 0; 18 | std::cout << buf << "\n"; 19 | } 20 | } 21 | 22 | pclose(fptr); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /UNIX/ipc/posix-sem-create.cpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 53 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main(int argc, char **argv) { 13 | 14 | if(argc != 3) { 15 | std::cerr << "Error requires two arguments..\n" << argv[0] << " path value\n"; 16 | exit(EXIT_FAILURE); 17 | } 18 | 19 | sem_t *s; 20 | int value = atoi(argv[2]); 21 | 22 | s = sem_open(argv[1], O_CREAT, S_IRUSR | S_IWUSR, value); 23 | 24 | if(s == SEM_FAILED) { 25 | std::cerr << "Error initializing semaphore..\n" << strerror(errno) << "\n"; 26 | exit(EXIT_FAILURE); 27 | } 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /UNIX/ipc/posix-sem-post.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Adapted from "the Linux Programming Interface" 3 | Chapter 53 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | 14 | int main(int argc, char **argv) { 15 | sem_t *s; 16 | if(argc != 2) { 17 | std::cerr << "Requires one argument\n" << argv[0] << " semaphore\n"; 18 | exit(EXIT_FAILURE); 19 | } 20 | s = sem_open(argv[1], 0); 21 | if(s == SEM_FAILED) { 22 | std::cerr << "Error open semaphore failed..\n" << strerror(errno) << "\n"; 23 | exit(EXIT_FAILURE); 24 | } 25 | if(sem_post(s) == -1) { 26 | std::cerr << "Semaphore post failed..\n" << strerror(errno) << "\n"; 27 | exit(EXIT_FAILURE); 28 | } 29 | std::cout << "Post succeded\n"; 30 | return EXIT_SUCCESS; 31 | } 32 | -------------------------------------------------------------------------------- /UNIX/ipc/posix-sem-unlink.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Adapted from "the Linux Programming Interface" 3 | Chapter 53 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | 14 | int main(int argc, char **argv) { 15 | if(argc != 2) { 16 | std::cerr << "Requires one argument..\n" << argv[0] << " path\n"; 17 | exit(EXIT_FAILURE); 18 | } 19 | if(sem_unlink(argv[1]) == -1) { 20 | std::cerr << "Error removing semaphore..\n" << strerror(errno) << "\n"; 21 | exit(EXIT_FAILURE); 22 | } 23 | return EXIT_SUCCESS; 24 | } 25 | -------------------------------------------------------------------------------- /UNIX/ipc/posix-sem-wait.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Adapted from "the Linux Programming Interface" 3 | Chapter 53 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | int main(int argc, char **argv) { 15 | sem_t *s; 16 | if(argc != 2) { 17 | std::cerr << "Error required arguments..\n" << argv[0] << " semaphore\n"; 18 | exit(EXIT_FAILURE); 19 | } 20 | s = sem_open(argv[1], 0); 21 | if(s == SEM_FAILED) { 22 | std::cerr << "Error opening semaphore..\n" << strerror(errno) << "\n"; 23 | exit(EXIT_FAILURE); 24 | } 25 | if(sem_wait(s) == -1) { 26 | std::cerr << "Error waiting..\n"; 27 | exit(EXIT_FAILURE); 28 | } 29 | std::cout << "wait successful\n"; 30 | return EXIT_SUCCESS; 31 | } 32 | -------------------------------------------------------------------------------- /UNIX/ipc/posix-shm-unlink.cpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 54 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main(int argc, char **argv) { 13 | 14 | if(argc != 2) { 15 | std::cerr << "Requires one argument..\n" << argv[0] << " path\n"; 16 | exit(EXIT_FAILURE); 17 | } 18 | 19 | if(shm_unlink(argv[1]) == -1) { 20 | std::cerr << "Error on shm_unlink: " << strerror(errno) << "\n"; 21 | exit(EXIT_FAILURE); 22 | } 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /UNIX/ipc/s.txt: -------------------------------------------------------------------------------- 1 | hey -------------------------------------------------------------------------------- /UNIX/ipc/sysv_sm.hpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 48 page 1002 3 | 4 | I was not very familar with these topics so this is 5 | more like the book than the others. 6 | 7 | */ 8 | 9 | 10 | #ifndef __SYSV_SM__HPP_ 11 | #define __SYSV_SM__HPP_ 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include "sysv_sem_binary.hpp" 20 | 21 | const int SHM_KEY = 0xDEADBEEF; 22 | const int SEM_KEY = 0x012456; 23 | 24 | const int IO_PERM = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP; 25 | 26 | 27 | const int WRITE_SEM = 0; 28 | const int READ_SEM = 1; 29 | 30 | #ifndef BUF_SIZE 31 | #define BUF_SIZE 1024 32 | #endif 33 | 34 | struct shmseg { 35 | int cnt; 36 | char buf[BUF_SIZE]; 37 | }; 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /UNIX/login/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: login-test 4 | 5 | login-test: login.cpp 6 | $(CXX) $(CXX_FLAGS) login.cpp -o login-test 7 | 8 | clean: 9 | rm -f login-test 10 | -------------------------------------------------------------------------------- /UNIX/memory/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: alloca-test memory-test realloc-test 4 | 5 | 6 | alloca-test: alloca-test.cpp 7 | $(CXX) $(CXX_FLAGS) alloca-test.cpp -o alloca-test 8 | memory-test: memory.cpp 9 | $(CXX) $(CXX_FLAGS) memory.cpp -o memory-test 10 | realloc-test: realloc.cpp 11 | $(CXX) $(CXX_FLAGS) realloc.cpp -o realloc-test 12 | 13 | clean: 14 | rm -f alloca-test memory-test realloc-test 15 | -------------------------------------------------------------------------------- /UNIX/memory/memory.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | struct Point { int x, y; }; 7 | 8 | void PrintPoint(struct Point *p) { 9 | std::cout << p->x << ":" << p->y << "\n"; 10 | } 11 | 12 | int main(int argc, char **argv) { 13 | 14 | struct Point *p; 15 | 16 | p = (Point*)malloc(sizeof(Point)); // allocate on the heap 17 | 18 | if(p == NULL) { 19 | std::cerr << "Error allocating memory..\n"; 20 | exit(0); 21 | } 22 | 23 | memset(p, 0, sizeof(Point)); 24 | 25 | p->x = 100; 26 | p->y = 200; 27 | 28 | PrintPoint(p); 29 | 30 | free(p); // free 31 | 32 | p = (Point*)calloc(1, sizeof(Point)); // allocate / initalize to zero 33 | 34 | if(p == NULL) { 35 | std::cerr << "Error allocating memory..\n"; 36 | exit(0); 37 | } 38 | 39 | PrintPoint(p); 40 | 41 | free(p); // free 42 | 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /UNIX/memory/realloc.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char *buf = (char*)realloc(NULL, sizeof(char) * 12); // initial alloc 6 | snprintf(buf, 12, "Hello World"); 7 | std::cout << "initial alloc: " << "12 bytes..\n buf is: " << buf << "\n"; 8 | char *nbuf = (char*)realloc(buf, sizeof(char) * 25); // resize memory buffer 9 | snprintf(nbuf, 25, "%s :) Resized", nbuf); 10 | std::cout << "after realloc: " << "25 bytes..\n buf is: " << nbuf << "\n"; 11 | 12 | free(nbuf); // release memory 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /UNIX/network/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 -Wall 2 | 3 | all: af_unix-stream-server af_unix-stream-client unix-udp-srv unix-udp-cli socktest-test listtest-test socktest2 4 | 5 | 6 | af_unix-stream-server: af_unix-stream-server.cpp 7 | $(CXX) $(CXX_FLAGS) af_unix-stream-server.cpp -o af_unix-stream-server 8 | 9 | af_unix-stream-client: af_unix-stream-client.cpp 10 | $(CXX) $(CXX_FLAGS) af_unix-stream-client.cpp -o af_unix-stream-client 11 | 12 | unix-udp-srv: unix-udp-srv.cpp 13 | $(CXX) $(CXX_FLAGS) unix-udp-srv.cpp -o unix-udp-srv 14 | 15 | unix-udp-cli: unix-udp-cli.cpp 16 | $(CXX) $(CXX_FLAGS) unix-udp-cli.cpp -o unix-udp-cli 17 | socktest-test: socktest.cpp socket.cpp 18 | $(CXX) $(CXX_FLAGS) socktest.cpp socket.cpp -o socktest-test 19 | 20 | listtest-test: listtest.cpp socket.cpp 21 | $(CXX) $(CXX_FLAGS) listtest.cpp socket.cpp -o listtest-test -pthread 22 | socktest2: socktest2.cpp socket.cpp 23 | $(CXX) $(CXX_FLAGS) socket.cpp socktest2.cpp -o socktest2 24 | 25 | clean: 26 | rm -f af_unix-stream-client af_unix-stream-server unix-udp-srv unix-udp-cli socktest-test listtest-test socktest2 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /UNIX/network/socktest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include"socket.hpp" 5 | 6 | 7 | int main(int argc, char **argv) { 8 | if(argc != 2) { 9 | std::cerr << "Requires one argument.\n" << argv[0] << " hostname\n"; 10 | exit(EXIT_FAILURE); 11 | } 12 | net::ignorePipeSignal(); 13 | net::Socket sock; 14 | if(sock.connectToHost(argv[1], "80", net::SocketType::STREAM) == -1) { 15 | std::cerr << "Could not connect to host.\n"; 16 | exit(EXIT_FAILURE); 17 | } 18 | std::ostringstream stream; 19 | stream << "GET /index.html HTTP/1.0\n\n"; 20 | 21 | sock.sendString(stream.str()); 22 | // read rest of data 23 | while(1) { 24 | std::string s; 25 | if(sock.readLine(s) > 0) { 26 | std::cout << s << "\n"; 27 | } else break; 28 | } 29 | sock.closeSocket(); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /UNIX/network/socktest2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include"socket.hpp" 5 | 6 | 7 | int main(int argc, char **argv) { 8 | if(argc != 3) { 9 | std::cerr << "Requires one argument.\n" << argv[0] << " hostname\n"; 10 | exit(EXIT_FAILURE); 11 | } 12 | net::ignorePipeSignal(); 13 | net::Socket sock; 14 | if(sock.connectToHost(argv[1], argv[2], net::SocketType::STREAM) == -1) { 15 | std::cerr << "Could not connect to host.\n"; 16 | exit(EXIT_FAILURE); 17 | } 18 | std::string text; 19 | std::cout << "Enter String: "; 20 | std::getline(std::cin, text); 21 | sock.sendString(text); 22 | sleep(1); 23 | char buf[256]; 24 | int bytes = sock.receive(buf, 255); 25 | buf[bytes] = 0; 26 | std::cout << "Returned: " << bytes << " buf: " << buf << "\n"; 27 | std::cout << "Quitting..\n"; 28 | sock.closeSocket(); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /UNIX/notify/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=gnu++11 2 | 3 | all: notify-example-test 4 | 5 | notify-example-test: inotify-test.cpp 6 | $(CXX) $(CXX_FLAGS) inotify-test.cpp -o notify-example-test 7 | 8 | clean: 9 | rm -f notify-example-test 10 | -------------------------------------------------------------------------------- /UNIX/proc/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: proc-info 4 | 5 | proc-info: procinfo.cpp 6 | $(CXX) $(CXX_FLAGS) procinfo.cpp -o proc-info 7 | 8 | clean: 9 | rm -f proc-info 10 | -------------------------------------------------------------------------------- /UNIX/proc/procinfo.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int main() { 9 | 10 | 11 | pid_t i = getpid(); 12 | std::ostringstream stream; 13 | stream << "/proc/" << i << "/status"; 14 | int fd = open(stream.str().c_str(), O_RDONLY); 15 | if(fd == -1) { 16 | std::cerr << "Error opening status file\n"; 17 | exit(EXIT_FAILURE); 18 | } 19 | 20 | ssize_t readBytes = 0; 21 | char buf[1024]; 22 | 23 | while((readBytes = read(fd, buf, 1024)) > 0) { 24 | write(1, buf, readBytes); 25 | } 26 | 27 | close(fd); 28 | 29 | utsname uts; 30 | 31 | if(uname(&uts) == -1) { 32 | std::cerr << "Error calling uname..\n"; 33 | exit(EXIT_FAILURE); 34 | } 35 | 36 | std::cout << uts.sysname << " " << uts.version << " " << uts.domainname << "\n"; 37 | 38 | return EXIT_SUCCESS; 39 | } 40 | -------------------------------------------------------------------------------- /UNIX/process/Makefile: -------------------------------------------------------------------------------- 1 | SOURCE_FILE=forktest.cpp 2 | OUTPUT_FILE=fork-test 3 | 4 | CFLAGS=-std=c++11 5 | 6 | all: $(OUTPUT_FILE) test-fork test-vfork many-fork exec-test system-test 7 | 8 | $(OUTPUT_FILE): $(SOURCE_FILE) 9 | $(CXX) $(CFLAGS) $(SOURCE_FILE) -o $(OUTPUT_FILE) 10 | 11 | test-fork: fork.cpp 12 | $(CXX) $(CFLAGS) fork.cpp -o test-fork 13 | test-vfork: vfork.cpp 14 | $(CXX) $(CFLAGS) vfork.cpp -o test-vfork 15 | many-fork: manyfork.cpp 16 | $(CXX) $(CFLAGS) manyfork.cpp -o many-fork 17 | exec-test: execve.cpp 18 | $(CXX) $(CFLAGS) execve.cpp -o exec-test 19 | system-test: system.cpp 20 | $(CXX) $(CFLAGS) system.cpp -o system-test 21 | clean: 22 | rm -f $(OUTPUT_FILE) test-fork test-vfork many-fork exec-test system-test 23 | 24 | -------------------------------------------------------------------------------- /UNIX/process/execve.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void err(const char *e) { 7 | std::cerr << "Error: " << strerror(errno) << "\n"; 8 | exit(EXIT_FAILURE); 9 | } 10 | 11 | int main() { 12 | 13 | const char *argv[] = { "execve", NULL }; 14 | const char *env[] = { NULL }; 15 | 16 | execve("/bin/bash", (char**)argv, (char**)env); 17 | err("An Error as Occoured..\n"); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /UNIX/process/fork.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | int main() { 8 | std::cout << "Process started..\n"; 9 | pid_t id = fork(); 10 | switch(id) { 11 | case -1: 12 | std::cerr << "Error on fork..\n"; 13 | exit(EXIT_FAILURE); 14 | break; 15 | case 0: 16 | std::cerr << "In Child process..\n"; 17 | // exec here 18 | _exit(EXIT_SUCCESS); // use _exit within child process 19 | break; 20 | default: 21 | std::cout << "In Parent..\n"; 22 | 23 | break; 24 | } 25 | int status = 0; 26 | waitpid(id, &status, 0); 27 | std::cout << "Program complete..\n"; 28 | exit(EXIT_SUCCESS); 29 | return EXIT_SUCCESS; 30 | } 31 | -------------------------------------------------------------------------------- /UNIX/process/forktest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | 8 | 9 | std::cout << "Fork test\n"; 10 | 11 | pid_t rt_value = 0; 12 | 13 | rt_value = fork(); 14 | 15 | if(rt_value == 0) { 16 | std::cout << "In Child..\n"; 17 | for(unsigned int i = 0; i < 100; ++i) { 18 | std::cout << "In Child process. \n"; 19 | } 20 | std::cout << "Child process done.\n"; 21 | _exit(EXIT_SUCCESS); 22 | 23 | } else { 24 | std::cout << "In Parent..\n"; 25 | for(unsigned int i = 0; i < 100; ++i) { 26 | std::cout << "In Parent process. \n"; 27 | } 28 | std::cout << "Parent process done..\n"; 29 | } 30 | 31 | int status = 0; 32 | waitpid(rt_value, &status, 0); 33 | std::cout << "Suceess!\n"; 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /UNIX/process/manyfork.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main(int argc, char **argv) { 11 | pid_t id; 12 | for(int i = 0; i < 4; ++i) { 13 | id = fork(); 14 | switch(id) { 15 | case -1: 16 | std::cerr << "Error on fork()\n"; 17 | exit(EXIT_FAILURE); 18 | break; 19 | case 0: { 20 | timeval t; 21 | gettimeofday(&t, 0); 22 | srand(t.tv_sec * t.tv_usec); 23 | std::cout << "In child process waiting....\n"; 24 | sleep(rand()%10); 25 | std::cout << getpid() << " is exiting..\n"; 26 | _exit(EXIT_SUCCESS); 27 | } 28 | break; 29 | default: 30 | break; 31 | } 32 | } 33 | pid_t cid; 34 | 35 | while((cid = wait(0)) != -1) 36 | continue; 37 | 38 | if(errno != ECHILD) 39 | std::cerr << "Error waiting..\n"; 40 | 41 | std::cout << "Complete.\n"; 42 | return EXIT_SUCCESS; 43 | } 44 | -------------------------------------------------------------------------------- /UNIX/pseudo/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 -Wall 2 | 3 | all: pseduoterm-test 4 | 5 | pseduoterm-test: terminal.cpp pterm.cpp 6 | $(CXX) $(CXX_FLAGS) terminal.cpp pterm.cpp -o pseduoterm-test 7 | 8 | clean: 9 | rm -f pseduoterm-test 10 | 11 | -------------------------------------------------------------------------------- /UNIX/pseudo/pterm.hpp: -------------------------------------------------------------------------------- 1 | /* Adapted from "the Linux Programming Interface" 2 | Chapter 64 3 | 4 | 5 | */ 6 | 7 | #ifndef __TERMINAL__H__ 8 | #define __TERMINAL__H__ 9 | 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | void error(const std::string &text, bool err = true); 21 | int pty_MasterOpen(char *name, size_t len); 22 | pid_t pty_Fork(int *m_fd, char *name, size_t len, const termios *st, winsize *s_size); 23 | int tty_SetRaw(int fd, termios *prev); 24 | 25 | 26 | 27 | 28 | #endif 29 | 30 | -------------------------------------------------------------------------------- /UNIX/pthread/Makefile: -------------------------------------------------------------------------------- 1 | PTHREAD_TEST_SOURCE=pthread-test.cpp 2 | PTHREAD_TEST_OUTPUT=pthread-test 3 | CFLAGS=-std=c++11 4 | 5 | all: $(PTHREAD_TEST_OUTPUT) pthread-self-test pthread-mutex-test pthread-cond-test pthread-once-test pthread-cancel-test 6 | 7 | $(PTHREAD_TEST_OUTPUT): $(PTHREAD_TEST_SOURCE) 8 | $(CXX) $(CFLAGS) $(PTHREAD_TEST_SOURCE) -o $(PTHREAD_TEST_OUTPUT) -pthread 9 | 10 | pthread-self-test: pthread-self.cpp 11 | $(CXX) $(CFLAGS) pthread-self.cpp -o pthread-self-test -pthread 12 | 13 | pthread-mutex-test: pthread-mutex.cpp 14 | $(CXX) $(CFLAGS) pthread-mutex.cpp -o pthread-mutex-test -pthread 15 | pthread-cond-test: pthread-cond.cpp 16 | $(CXX) $(CFLAGS) pthread-cond.cpp -o pthread-cond-test -pthread 17 | pthread-once-test: pthread-once.cpp 18 | $(CXX) $(CFLAGS) pthread-once.cpp -o pthread-once-test -pthread 19 | pthread-cancel-test: pthread-cancel.cpp 20 | $(CXX) $(CFLAGS) pthread-cancel.cpp -o pthread-cancel-test -pthread 21 | 22 | clean: 23 | rm -f $(PTHREAD_TEST_OUTPUT) pthread-self-test pthread-mutex-test pthread-cond-test pthread-once-test pthread-cancel-test 24 | -------------------------------------------------------------------------------- /UNIX/pthread/pthread-mutex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; 6 | 7 | const int MAX_THREADS = 10; 8 | const int MAX_ITERATIONS = 100; 9 | 10 | 11 | void *thread_function(void *arg) { 12 | long id = (long)arg; 13 | for(unsigned int i = 0; i < MAX_ITERATIONS; ++i) { 14 | pthread_mutex_lock(&mut); 15 | std::cout << "in thread index: " << id << "\n"; 16 | pthread_mutex_unlock(&mut); 17 | } 18 | return 0; 19 | } 20 | 21 | 22 | int main() { 23 | std::cout << "Starting threads..\n"; 24 | pthread_t t_id[MAX_THREADS]; 25 | 26 | for(long i = 0; i < MAX_THREADS; ++i) { 27 | pthread_create(&t_id[i], 0, thread_function, (void*)i); 28 | } 29 | 30 | for(int i = 0; i < MAX_THREADS; ++i) { 31 | pthread_join(t_id[i], 0); 32 | } 33 | 34 | return EXIT_SUCCESS; 35 | } 36 | -------------------------------------------------------------------------------- /UNIX/pthread/pthread-self.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | void _error(const std::string &text); 10 | 11 | pthread_t tid; 12 | 13 | void *threadfunc(void *v) { 14 | std::cout << "Hello Thread World...\n"; 15 | if(pthread_equal(tid, pthread_self())) { 16 | std::cout << "Yeah its me..\n"; 17 | } 18 | return (void*) 100; 19 | } 20 | 21 | 22 | int main() { 23 | std::cout << "Hello World from main function..\n"; 24 | int rt_val = 0; 25 | rt_val = pthread_create(&tid, 0, threadfunc, (void*)0); 26 | 27 | if(rt_val != 0) 28 | _error("pthread_create"); 29 | 30 | void *return_value; 31 | rt_val = pthread_join(tid, &return_value); 32 | 33 | if(rt_val != 0) 34 | _error("pthread_join"); 35 | 36 | if(((long)return_value) != 100) 37 | std::cout << "Something went wrong..\n"; 38 | else 39 | std::cout << "Yeah everything is working okay..\n"; 40 | 41 | return 0; 42 | } 43 | 44 | void _error(const std::string &text) { 45 | std::cerr << "Error: " << text << "\n"; 46 | exit(EXIT_FAILURE); 47 | } 48 | -------------------------------------------------------------------------------- /UNIX/pthread/pthread-test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | void *threadFunction(void *v) { 7 | for(unsigned int i = 0; i < 100; ++i) 8 | std::cout << "Hello World\n"; 9 | 10 | return 0; 11 | 12 | } 13 | 14 | int main() { 15 | std::cout << "pthread test\n"; 16 | pthread_t id[4]; 17 | for(unsigned int i = 0; i < 4; ++i) { 18 | pthread_create(&id[i], NULL, threadFunction, NULL); // run concurrently will out put at same time 19 | } 20 | 21 | for(unsigned int i = 0; i < 4; ++i) { 22 | pthread_join(id[i],NULL); 23 | } 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /UNIX/sched/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: sched-get sched-set 4 | 5 | 6 | sched-get: get.cpp 7 | $(CXX) $(CXX_FLAGS) get.cpp -o sched-get 8 | sched-set: set.cpp 9 | $(CXX) $(CXX_FLAGS) set.cpp -o sched-set 10 | clean: 11 | rm -f sched-get sched-set 12 | 13 | -------------------------------------------------------------------------------- /UNIX/sched/README: -------------------------------------------------------------------------------- 1 | How to test these programs: 2 | 3 | jared@lostvm /mnt/hgfs/newcode/cplusplus11.Examples/UNIX/sched $ su 4 | Password: 5 | 6 | lostvm sched # 7 | lostvm sched # sleep 100 & 8 | [1] 42746 9 | lostvm sched # ./sched-get 42746 10 | 42746: OTHER 0 0 11 | lostvm sched # ./sched-set f 25 42746 12 | lostvm sched # ./sched-get 42746 13 | 42746: FIFO 1 0 14 | 15 | 16 | sched-set params: 17 | 18 | f stands for FIFO 19 | r stands for Round Robin 20 | b stands for BATCH 21 | i stands for IDLE 22 | 23 | must have privlages to increase 24 | -------------------------------------------------------------------------------- /UNIX/setjmp/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: setjmptest 4 | 5 | setjmptest: setjmptest.cpp 6 | $(CXX) $(CXX_FLAGS) setjmptest.cpp -o setjmptest 7 | 8 | clean: 9 | rm -f setjmptest 10 | 11 | -------------------------------------------------------------------------------- /UNIX/setjmp/setjmptest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | jmp_buf j_val; 5 | 6 | int testF1(int x) { 7 | if(x == 1) longjmp(j_val, 1); // #1 jump from here back to setjmp return value 1 8 | ++x; 9 | return x; 10 | } 11 | 12 | int rtVal(int val) { 13 | int x_val = testF1(val); 14 | if(x_val == 1) { 15 | std::cout << "Value is: 1\n"; 16 | } 17 | return x_val; 18 | } 19 | 20 | 21 | int main(int argc, char **argv) { 22 | std::cout << "Pass no arguments to test longjmp pass at least 1 to complete function\nEnter test: "; 23 | switch(setjmp(j_val)) { // first call retuns 0 after that value passed to longjmp 24 | case 0: { 25 | std::cout << "Returned after inital call.\n"; 26 | if(rtVal(argc) == 3) { 27 | std::cout << "value is 3\n"; 28 | } else { 29 | std::cout << "value is not 3\n"; 30 | } 31 | } 32 | break; 33 | case 1: { 34 | std::cout << "We jumped back from testF1.\n"; 35 | } 36 | break; 37 | } 38 | 39 | return EXIT_SUCCESS; 40 | } 41 | -------------------------------------------------------------------------------- /UNIX/shared/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | make -C simple_lib 3 | make -C simple_lib2 4 | make -C dynamic_load 5 | make -C dynamic_init 6 | clean: 7 | make -C simple_lib clean 8 | make -C simple_lib2 clean 9 | make -C dynamic_load clean 10 | make -C dynamic_init clean 11 | -------------------------------------------------------------------------------- /UNIX/shared/Makefile.linux: -------------------------------------------------------------------------------- 1 | all: 2 | make -C simple_lib -f Makefile.linux 3 | make -C simple_lib2 -f Makefile.linux 4 | make -C dynamic_load -f Makefile.linux 5 | make -C dynamic_init -f Makefile.linux 6 | clean: 7 | make -C simple_lib -f Makefile.linux clean 8 | make -C simple_lib2 -f Makefile.linux clean 9 | make -C dynamic_load -f Makefile.linux clean 10 | make -C dynamic_init -f Makefile.linux clean 11 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_init/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.dylib program 4 | 5 | libdemo.dylib: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -o libdemo.dylib 7 | 8 | program: prog.cpp header.h 9 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -ldl 10 | clean: 11 | rm -f program libdemo.dylib 12 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_init/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.so prog 4 | 5 | libdemo.so: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -o libdemo.so 7 | 8 | prog: prog.cpp header.h 9 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -ldl 10 | clean: 11 | rm -f program libdemo.so 12 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_init/header.h: -------------------------------------------------------------------------------- 1 | #ifndef __HEADER__ 2 | #define __HEADER__ 3 | 4 | 5 | extern "C" void sayHello(); 6 | 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_init/lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "header.h" 3 | 4 | 5 | void __attribute__((constructor)) init() { 6 | std::cout << "Init called..\n"; 7 | } 8 | 9 | void __attribute__((destructor)) release() { 10 | std::cout << "Release called...\n"; 11 | } 12 | 13 | void sayHello() { 14 | std::cout << "Hello World\n"; 15 | } 16 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_init/prog.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void error(const std::string &text); 6 | 7 | typedef void (*sayHello)(); 8 | 9 | int main() { 10 | void *libHandle; 11 | 12 | #if defined(__APPLE__) 13 | libHandle = dlopen("libdemo.dylib", RTLD_LAZY); 14 | #else 15 | libHandle = dlopen("./libdemo.so", RTLD_LAZY); 16 | #endif 17 | 18 | if(libHandle == NULL) 19 | error(dlerror()); 20 | 21 | (void)dlerror(); 22 | 23 | sayHello say; 24 | say = reinterpret_cast(dlsym(libHandle,"sayHello")); 25 | const char *e = dlerror(); 26 | if(e != NULL) 27 | error(e); 28 | std::cout << "Shared Object: "; 29 | if(say != NULL) 30 | say(); 31 | 32 | dlclose(libHandle); 33 | return EXIT_SUCCESS; 34 | } 35 | 36 | 37 | void error(const std::string &text) { 38 | std::cerr << "Error: " << text << "\n"; 39 | exit(EXIT_FAILURE); 40 | } 41 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_load/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.dylib program 4 | 5 | libdemo.dylib: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -o libdemo.dylib 7 | 8 | program: prog.cpp header.h 9 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -ldl 10 | clean: 11 | rm -f program libdemo.dylib 12 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_load/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.so prog 4 | 5 | libdemo.so: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -o libdemo.so 7 | 8 | prog: prog.cpp header.h 9 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -ldl 10 | clean: 11 | rm -f program libdemo.so 12 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_load/header.h: -------------------------------------------------------------------------------- 1 | #ifndef __HEADER__ 2 | #define __HEADER__ 3 | 4 | 5 | extern "C" void sayHello(); 6 | 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_load/lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "header.h" 3 | 4 | void sayHello() { 5 | std::cout << "Hello World\n"; 6 | } 7 | -------------------------------------------------------------------------------- /UNIX/shared/dynamic_load/prog.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void error(const std::string &text); 6 | 7 | typedef void (*sayHello)(); 8 | 9 | int main() { 10 | void *libHandle; 11 | 12 | #if defined(__APPLE__) 13 | libHandle = dlopen("libdemo.dylib", RTLD_LAZY); 14 | #else 15 | libHandle = dlopen("./libdemo.so", RTLD_LAZY); 16 | #endif 17 | 18 | if(libHandle == NULL) 19 | error(dlerror()); 20 | 21 | (void)dlerror(); 22 | 23 | sayHello say; 24 | say = reinterpret_cast(dlsym(libHandle,"sayHello")); 25 | const char *e = dlerror(); 26 | if(e != NULL) 27 | error(e); 28 | std::cout << "Shared Object: "; 29 | if(say != NULL) 30 | say(); 31 | 32 | dlclose(libHandle); 33 | return EXIT_SUCCESS; 34 | } 35 | 36 | 37 | void error(const std::string &text) { 38 | std::cerr << "Error: " << text << "\n"; 39 | exit(EXIT_FAILURE); 40 | } 41 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.dylib program 4 | 5 | libdemo.dylib: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -o libdemo.dylib 7 | 8 | program: prog.cpp header.h 9 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -L. -ldemo 10 | clean: 11 | rm -f program libdemo.dylib 12 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.so prog 4 | 5 | libdemo.so: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -o libdemo.so 7 | 8 | prog: prog.cpp header.h 9 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -L. -ldemo 10 | clean: 11 | rm -f program libdemo.so 12 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib/README: -------------------------------------------------------------------------------- 1 | to run on Linux use: 2 | 3 | $ LD_LIBRARY_PATH=. ./program 4 | 5 | OS X should just be 6 | 7 | $ ./program 8 | 9 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib/header.h: -------------------------------------------------------------------------------- 1 | #ifndef __HEADER__ 2 | #define __HEADER__ 3 | 4 | 5 | extern void sayHello(); 6 | 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib/lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "header.h" 3 | 4 | void sayHello() { 5 | std::cout << "Hello World\n"; 6 | } 7 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib/prog.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "header.h" 3 | 4 | 5 | int main() { 6 | 7 | std::cout << "Shared Object: "; 8 | sayHello(); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib2/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.dylib program 4 | 5 | libdemo.dylib: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -dynamiclib -install_name "libdemo.dylib.1" -o libdemo.dylib.1.0.0 7 | ln -sf libdemo.dylib.1.0.0 libdemo.dylib.1 8 | ln -sf libdemo.dylib.1 libdemo.dylib 9 | 10 | program: prog.cpp header.h 11 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -L. -ldemo 12 | clean: 13 | rm -f program libdemo.dylib libdemo.dylib.1 libdemo.dylib.1.0.0 14 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib2/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: libdemo.so prog 4 | 5 | libdemo.so: lib.cpp 6 | $(CXX) $(CXX_FLAGS) -fPIC lib.cpp -shared -Wl,-soname,libdemo.so.1 -o libdemo.so.1.0.0 7 | ln -sf libdemo.so.1.0.0 libdemo.so.1 8 | ln -sf libdemo.so.1 libdemo.so 9 | 10 | prog: prog.cpp header.h 11 | $(CXX) $(CXX_FLAGS) prog.cpp -o program -L. -ldemo 12 | clean: 13 | rm -f program libdemo.so libdemo.so.1.0.0 libdemo.so.1 libdemo.so 14 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib2/README: -------------------------------------------------------------------------------- 1 | to run on Linux use: 2 | 3 | $ LD_LIBRARY_PATH=. ./program 4 | 5 | OS X should just be 6 | 7 | $ ./program 8 | 9 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib2/header.h: -------------------------------------------------------------------------------- 1 | #ifndef __HEADER__ 2 | #define __HEADER__ 3 | 4 | 5 | extern void sayHello(); 6 | 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib2/lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "header.h" 3 | 4 | void sayHello() { 5 | std::cout << "Hello World\n"; 6 | } 7 | -------------------------------------------------------------------------------- /UNIX/shared/simple_lib2/prog.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "header.h" 3 | 4 | 5 | int main() { 6 | 7 | std::cout << "Shared Object: "; 8 | sayHello(); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /UNIX/signal/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: signal-test-send signal-test-recv sigaction-test isprocess-test 4 | 5 | signal-test-send: signal-test-send.cpp 6 | $(CXX) $(CXX_FLAGS) signal-test-send.cpp -o signal-test-send 7 | 8 | signal-test-recv: signal-test.cpp 9 | $(CXX) $(CXX_FLAGS) signal-test.cpp -o signal-test-recv 10 | 11 | sigaction-test: sigaction-test.cpp 12 | $(CXX) $(CXX_FLAGS) sigaction-test.cpp -o sigaction-test 13 | 14 | isprocess-test: isprocess.cpp 15 | $(CXX) $(CXX_FLAGS) isprocess.cpp -o isprocess-test 16 | 17 | clean: 18 | rm -f signal-test-send signal-test-recv sigaction-test isprocess-test 19 | -------------------------------------------------------------------------------- /UNIX/signal/isprocess.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | int main(int argc, char **argv) { 10 | 11 | if(argc != 3) { 12 | std::cerr << argv[0] << " processid signum\n"; 13 | exit(EXIT_FAILURE); 14 | } 15 | 16 | long pid = atol(argv[1]); 17 | long signum = atol(argv[2]); 18 | 19 | if(pid <= 0) { 20 | std::cerr << "Invalid process id..\n"; 21 | exit(EXIT_FAILURE); 22 | } 23 | 24 | int s; 25 | s = kill(pid, signum); 26 | if(s == 0) { 27 | std::cout << "Process exisits..\n"; 28 | } else { 29 | if(errno == EPERM) 30 | std::cout << "Process exisits but we don't have permission.\n"; 31 | else if(errno == ESRCH) 32 | std::cout << "Process does not exisit..\n"; 33 | else { 34 | std::cout << "Kill.\n"; 35 | exit(EXIT_FAILURE); 36 | } 37 | } 38 | 39 | return EXIT_SUCCESS; 40 | } 41 | -------------------------------------------------------------------------------- /UNIX/signal/sigaction-test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void output(const char *src) { 7 | write(1, src, strlen(src)); 8 | } 9 | 10 | void handler(int sig) { 11 | output(" Caught SIGINT in Handler...\n"); 12 | } 13 | 14 | int main() { 15 | struct sigaction sa; 16 | sigemptyset(&sa.sa_mask); 17 | sa.sa_flags = 0; 18 | sa.sa_handler = handler; 19 | 20 | if(sigaction(SIGINT, &sa, NULL) == -1) { 21 | std::cerr << "Error on sigaction: \n"; 22 | exit(EXIT_FAILURE); 23 | } 24 | 25 | while(1) { 26 | std::cout << "Waiting for signal...\n"; 27 | sleep(3); 28 | } 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /UNIX/signal/signal-test.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Run this program and use Control+C to 4 | send the SIGINT signal and it will recgonize this 5 | to exit the program press Ctrl+/ to send quit signal 6 | 7 | */ 8 | 9 | 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | void writeOutput(const char *src) { 17 | write(1, src, strlen(src)); // printf is not reentrant and not safe 18 | // for use with a signal, so we use write that is async signal safe 19 | } 20 | 21 | 22 | void handler(int s) { 23 | writeOutput(" Signal SIGINT caught\n"); 24 | } 25 | 26 | int main(int argc, char **argv) { 27 | 28 | if(signal(SIGINT, handler) == SIG_ERR) { 29 | std::cerr << "Error creating signal..\n"; 30 | exit(EXIT_FAILURE); 31 | } 32 | 33 | int index = 0; 34 | 35 | while(1) { 36 | ++index; 37 | sleep(3); 38 | std::cout << "index: " << index << "\n"; 39 | } 40 | 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /UNIX/syslog/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: log-test 4 | 5 | log-test: log.cpp 6 | $(CXX) $(CXX_FLAGS) log.cpp -o log-test 7 | clean: 8 | rm -f log-test 9 | 10 | -------------------------------------------------------------------------------- /UNIX/syslog/log.cpp: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | Write to syslog 4 | To see the message 5 | 6 | $ cat /var/log/system.log 7 | 8 | or 9 | 10 | $ tail -f /var/log/system.log 11 | 12 | */ 13 | 14 | #include 15 | #include 16 | 17 | 18 | int main(int argc, char **argv) { 19 | if(argc != 2) { 20 | std::cout << "Error requires one argument..\n"; 21 | exit(EXIT_FAILURE); 22 | } 23 | 24 | openlog(argv[0], LOG_PID | LOG_CONS | LOG_NOWAIT, LOG_LOCAL0); 25 | syslog(LOG_WARNING, "Syslog test: %s", argv[1]); 26 | closelog(); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /UNIX/time/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: gettime-test tick-test 4 | 5 | gettime-test: gettime.cpp 6 | $(CXX) $(CXX_FLAGS) gettime.cpp -o gettime-test 7 | 8 | tick-test: gettickcount.cpp 9 | $(CXX) $(CXX_FLAGS) gettickcount.cpp -o tick-test 10 | 11 | clean: 12 | rm -f gettime-test tick-test 13 | 14 | -------------------------------------------------------------------------------- /UNIX/time/gettickcount.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | uint32_t getTickCount() { 8 | timeval val; 9 | gettimeofday(&val, 0); 10 | uint32_t t = (val.tv_sec * 1000) + (val.tv_usec / 1000); 11 | return t; 12 | } 13 | 14 | 15 | int main(int argc, char **argv) { 16 | uint32_t stop = 0, diff = 0; 17 | std::cout << "Sleeping for 1 second..\n"; 18 | uint32_t start = getTickCount(); 19 | sleep(1); 20 | stop = getTickCount(); 21 | diff = stop-start; 22 | std::cout << "Amount of ticks: " << diff << "\n"; 23 | return EXIT_SUCCESS; 24 | } 25 | -------------------------------------------------------------------------------- /UNIX/time/gettime.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main() { 7 | 8 | time_t passed = time(0); 9 | std::cout << "Unix Epoch: " << passed << " seconds since Thursday January 1, 1970\n"; 10 | 11 | timeval t; 12 | gettimeofday(&t, 0); 13 | std::cout << "Time is at: " << t.tv_sec << ":" << t.tv_usec << "\n"; 14 | std::cout << "Waiting two seconds..\n"; 15 | sleep(2); 16 | gettimeofday(&t, 0); 17 | std::cout << "Time is at: " << t.tv_sec << ":" << t.tv_usec << "\n"; 18 | passed = time(0); 19 | std::cout << "Current: " << ctime(&passed) << "\n"; 20 | tm *time_at; 21 | time_at = localtime(&passed); 22 | char buffer[1024]; 23 | size_t s; 24 | s = strftime(buffer, 1024, "%D", time_at); 25 | if(s > 0) { 26 | std::cout << "Date: " << buffer << "\n"; 27 | } 28 | 29 | return EXIT_SUCCESS; 30 | } 31 | -------------------------------------------------------------------------------- /UNIX/timer/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: timer-test alarm-test nano-test nano-sleep-test 4 | 5 | timer-test: timer.cpp 6 | $(CXX) $(CXX_FLAGS) timer.cpp -o timer-test 7 | 8 | alarm-test: alarm.cpp 9 | $(CXX) $(CXX_FLAGS) alarm.cpp -o alarm-test 10 | 11 | nano-test: nanosleep.cpp 12 | $(CXX) $(CXX_FLAGS) nanosleep.cpp -o nano-test 13 | 14 | nano-sleep-test: nanosleep_wait.cpp 15 | $(CXX) $(CXX_FLAGS) nanosleep_wait.cpp -o nano-sleep-test 16 | 17 | clean: 18 | rm -f alarm-test timer-test nano-test nano-sleep-test 19 | -------------------------------------------------------------------------------- /UNIX/timer/alarm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | void alarmHandler(int sig) { 10 | std::cout << "Got alarm..\n"; 11 | exit(EXIT_SUCCESS); 12 | } 13 | 14 | int main(int argc, char **argv) { 15 | 16 | struct sigaction sa; 17 | sigemptyset(&sa.sa_mask); 18 | sa.sa_flags = 0; 19 | sa.sa_handler = alarmHandler; 20 | 21 | if(sigaction(SIGALRM, &sa, NULL) == -1) { 22 | std::cerr << "Error on signal: " << strerror(errno) << "\n"; 23 | exit(EXIT_FAILURE); 24 | } 25 | 26 | alarm(4); 27 | 28 | while(1) { 29 | std::cout << "waiting...\n"; 30 | } 31 | 32 | return 0; 33 | 34 | } 35 | -------------------------------------------------------------------------------- /UNIX/user/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: users-test crypt-test 4 | 5 | users-test: users.cpp 6 | $(CXX) $(CXX_FLAGS) users.cpp -o users-test 7 | crypt-test: crypt.cpp 8 | $(CXX) $(CXX_FLAGS) crypt.cpp -o crypt-test 9 | clean: 10 | rm -f users-test crypt-test 11 | -------------------------------------------------------------------------------- /UNIX/user/Makefile.linux: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: users-test crypt-test 4 | 5 | users-test: users.cpp 6 | $(CXX) $(CXX_FLAGS) users.cpp -o users-test 7 | crypt-test: crypt.cpp 8 | $(CXX) $(CXX_FLAGS) crypt.cpp -o crypt-test -lcrypt 9 | clean: 10 | rm -f users-test crypt-test 11 | -------------------------------------------------------------------------------- /UNIX/user/crypt.cpp: -------------------------------------------------------------------------------- 1 | #define _XOPEN_SOURCE 2 | #include 3 | #include 4 | 5 | int main() { 6 | char *password = getpass("Enter Password: "); 7 | char *encrypted = crypt(password, "0x"); // encrypt password one way 8 | for(char *p = password; *p != 0; ++p) *p = '\0'; 9 | std::cout << "Password encrypted is: " << encrypted << "\n"; 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /UNIX/user/gen_pass/Makefile: -------------------------------------------------------------------------------- 1 | #CXX=clang++-5.0 2 | CXXFLAGS=-std=c++11 3 | LDFLAGS= 4 | GEN_PASS=gen_pass 5 | 6 | all: $(GEN_PASS) 7 | 8 | $(GEN_PASS): $(GEN_PASS).cpp 9 | $(CXX) $(CXXFLAGS) $(GEN_PASS).cpp -o $(GEN_PASS) $(LDFLAGS) 10 | clean: 11 | rm -f $(GEN_PASS) 12 | 13 | -------------------------------------------------------------------------------- /UNIX/user/gen_pass/Makefile.linux: -------------------------------------------------------------------------------- 1 | #CXX=clang++-5.0 2 | CXXFLAGS=-std=c++11 3 | LDFLAGS= -lcrypt 4 | GEN_PASS=gen_pass 5 | 6 | all: $(GEN_PASS) 7 | 8 | $(GEN_PASS): $(GEN_PASS).cpp 9 | $(CXX) $(CXXFLAGS) $(GEN_PASS).cpp -o $(GEN_PASS) $(LDFLAGS) 10 | clean: 11 | rm -f $(GEN_PASS) 12 | 13 | -------------------------------------------------------------------------------- /UNIX/user/gen_pass/gen_pass.cpp: -------------------------------------------------------------------------------- 1 | #define _XOPEN_SOURCE 2 | #include 3 | #include 4 | #include 5 | 6 | int main(int argc, char **argv) { 7 | char *pw = getpass("Enter password: "); 8 | std::string ent = getpass("Enter site: "); 9 | char *encrypted_start = crypt(pw, ent.c_str()); 10 | for(char *p = pw; *p != 0; p++) *p = 0; 11 | std::cout << "Password: " << encrypted_start << "\n"; 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /UNIX/user/users.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | 7 | 8 | passwd *pwd; 9 | 10 | while((pwd = getpwent()) != NULL) { 11 | std::cout << "user: " << pwd->pw_name << " id: " << pwd->pw_uid << " shell: " << pwd->pw_shell << "\n"; 12 | 13 | } 14 | 15 | endpwent(); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /algorithm/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: for_each_test transform_test find_if_test sort-test 4 | 5 | for_each_test: for_each.cpp 6 | $(CXX) $(CXX_FLAGS) for_each.cpp -o for_each_test 7 | transform_test: transform.cpp 8 | $(CXX) $(CXX_FLAGS) transform.cpp -o transform_test 9 | find_if_test: find_if.cpp 10 | $(CXX) $(CXX_FLAGS) find_if.cpp -o find_if_test 11 | sort-test: sort.cpp 12 | $(CXX) $(CXX_FLAGS) sort.cpp -o sort-test 13 | clean: 14 | rm -f for_each_test transform_test find_if_test sort-test 15 | -------------------------------------------------------------------------------- /algorithm/find_if.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main() { 7 | std::vector vec; 8 | std::cout << "Enter multiple strings use quit to terminate\n"; 9 | std::string value; 10 | do { 11 | std::cin >> value; 12 | vec.push_back(value); 13 | } while(value!="quit"); 14 | 15 | auto contains = std::find_if(vec.begin(), vec.end(), [](std::string text) { 16 | return (text == "hello"); 17 | }); 18 | 19 | if(*contains == "hello") { 20 | std::cout << "You entered hello\n"; 21 | } else { 22 | std::cout << "You didn't enter hello\n"; 23 | } 24 | return 0; 25 | } -------------------------------------------------------------------------------- /algorithm/for_each.cpp: -------------------------------------------------------------------------------- 1 | 2 | /* for_each example */ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | void proc_elem(int value) { 10 | std::cout << "Value is: " << value << "\n"; 11 | } 12 | 13 | int main() { 14 | 15 | std::vector values { 0, 1, 99, 48, 64, 2, 1 }; 16 | std::sort(values.begin(), values.end()); 17 | std::for_each(values.begin(), values.end(), proc_elem); 18 | std::for_each(values.begin(), values.end(), [](int value) { 19 | std::cout << "Lambda value: " << value << "\n"; 20 | }); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /algorithm/transform.cpp: -------------------------------------------------------------------------------- 1 | /* Algorithm function transform test */ 2 | 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int main() { 10 | std::cout << "Before: \n"; 11 | std::vector v1 {0,1,4,2,6,5,4}; 12 | std::copy(v1.begin(), v1.end(), std::ostream_iterator(std::cout, " ")); 13 | std::cout << "\nAfter: \n"; 14 | std::vector v2; 15 | std::transform(v1.cbegin(), v1.cend(), std::back_inserter(v2),[](int value) { 16 | return -value; 17 | }); 18 | std::copy(v2.begin(), v2.end(), std::ostream_iterator(std::cout, " ")); 19 | std::cout << "\n"; 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /allocator/Makefile: -------------------------------------------------------------------------------- 1 | # change to g++ if you want 2 | CXX=c++ 3 | CXX_FLAGS=-Wall -std=c++11 4 | AL_BIN=al-test 5 | 6 | all: al-test 7 | 8 | al-test: al.cc 9 | $(CXX) al.cc -o $(AL_BIN) $(CXX_FLAGS) 10 | clean: 11 | rm -f $(AL_BIN) 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /array/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -Wall -std=c++11 3 | 4 | all: ar-test ar2-test 5 | 6 | ar-test: ar.cc 7 | $(CXX) $(FLAGS) ar.cc -o ar-test 8 | ar2-test: ar2.cc 9 | $(CXX) $(FLAGS) ar2.cc -o ar2-test 10 | clean: 11 | rm -f ar-test ar2-test 12 | -------------------------------------------------------------------------------- /arraybyte/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS=-std=c++11 3 | 4 | all: array-test 5 | 6 | array-test: main.cpp 7 | $(CXX) main.cpp -o array-test $(CXX_FLAGS) 8 | clean: 9 | rm -f array-test 10 | -------------------------------------------------------------------------------- /arraybyte/arraybyte.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __ARRAY_BYTE_H_ 2 | #define __ARRAY_BYTE_H_ 3 | 4 | 5 | template 6 | class ArrayByte { 7 | public: 8 | ArrayByte() = default; 9 | 10 | ArrayByte(const T &type) { 11 | b.value = type; 12 | } 13 | 14 | ArrayByte(const ArrayByte &a) { 15 | b = a.b; 16 | } 17 | 18 | ArrayByte(ArrayByte &&) = delete; 19 | 20 | ArrayByte &operator=(const ArrayByte &a) { 21 | b = a.b; 22 | return *this; 23 | } 24 | 25 | ArrayByte &operator=(const T &type) { 26 | b.value = type; 27 | return *this; 28 | } 29 | 30 | ArrayByte operator=(ArrayByte &&) = delete; 31 | 32 | unsigned char &operator[](unsigned int pos) { 33 | return b.bytes[pos]; 34 | } 35 | 36 | unsigned int size() { return sizeof(T); } 37 | 38 | protected: 39 | union { 40 | T value; 41 | unsigned char bytes[sizeof(T)]; 42 | } b; 43 | }; 44 | 45 | 46 | 47 | #endif 48 | -------------------------------------------------------------------------------- /arraybyte/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include"arraybyte.hpp" 3 | 4 | template 5 | void printOut(ArrayByte &value) { 6 | for(unsigned int i = 0; i < value.size(); ++i) { 7 | std::cout << "POS: " << i << " BYTE: " << (unsigned int) value[i] << "\n"; 8 | } 9 | } 10 | 11 | int main(int argc, char **argv) { 12 | unsigned int v = 0xFFFFFFFF; 13 | ArrayByte value(v); 14 | 15 | printOut(value); 16 | 17 | value = 0xFF00FFFE; 18 | 19 | printOut(value); 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /assert/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: assert-test 4 | 5 | assert-test: 6 | $(CXX) $(CXX_FLAGS) main.cpp -o assert-test 7 | clean: 8 | rm -f assert-test 9 | -------------------------------------------------------------------------------- /assert/main.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include 4 | #include 5 | 6 | // main function 7 | int main() { 8 | int x = 1; 9 | int y = 5; 10 | std::cout << "(x+y) == 5\n"; 11 | // assert should be true 12 | assert((x*y) == 5); 13 | char *ptr = new char [100]; 14 | // should be true 15 | assert(ptr != 0); 16 | delete [] ptr; 17 | ptr = 0; 18 | // should fail 19 | assert(ptr != 0); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /auto/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS= -std=c++11 3 | all: auto-test auto-test2 4 | 5 | auto-test: autotest.cc 6 | $(CXX) $(CXX_FLAGS) autotest.cc -o auto-test 7 | auto-test2: autotest2.cpp 8 | $(CXX) $(CXX_FLAGS) autotest2.cpp -o auto-test2 9 | clean: 10 | rm -f auto-test auto-test2 11 | -------------------------------------------------------------------------------- /auto/autotest.cc: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | written by Jared Bruni 4 | auto example 5 | 6 | */ 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | namespace driver { 14 | void main(); 15 | // you can use auto for return type of a function 16 | 17 | auto temp_function(std::string s) -> decltype(s) { 18 | return s+"add some stuff"; 19 | } 20 | } 21 | 22 | 23 | int main(int argc, char **argv) { 24 | driver::main(); 25 | return 0; 26 | } 27 | 28 | void driver::main() { 29 | std::vector ar = { "hello", "world", "this is a string" }; 30 | auto len = ar.size(); 31 | std::cout << "Size: " << len << "\n"; 32 | auto loop_func = [&](std::string data) -> std::string { 33 | // or auto for a lambda expression 34 | 35 | std::ostringstream stream; 36 | // auto here insted of full def. 37 | 38 | for(auto i = ar.begin(); i != ar.end(); ++i) { 39 | stream << data << " " << *i << " "; 40 | } 41 | return stream.str(); 42 | }; 43 | std::string value; 44 | value = temp_function(loop_func("data := ")); 45 | std::cout << value << "\n"; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /bin2cpp_memfile/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: bin2cpp memfile-demo extract-image 4 | 5 | memfile-demo: memfile_demo.cpp 6 | $(CXX) $(CXX_FLAGS) -I. memfile_demo.cpp resource/resource.cpp -o memfile-demo 7 | 8 | bin2cpp: bin2cpp.cpp 9 | $(CXX) $(CXX_FLAGS) bin2cpp.cpp -o bin2cpp 10 | 11 | extract-image: extract_image.cpp 12 | $(CXX) $(CXX_FLAGS) extract_image.cpp image_res/floyd.cpp -o extract-image -I. 13 | 14 | install: bin2cpp 15 | cp bin2cpp /usr/local/bin 16 | 17 | clean: 18 | rm -f bin2cpp memfile-demo extract-image 19 | -------------------------------------------------------------------------------- /bin2cpp_memfile/README.md: -------------------------------------------------------------------------------- 1 | Program is simple, 2 | 3 | invoke from the terminal with two arguments, one the source file to 4 | turn into a C++ array and one the output file name. The output file name 5 | will have .cpp and .h appended to the end of it and you use those two 6 | source files in your project to embed the resource. Then there is 7 | memfile.hpp, use this header file to read the array in your program 8 | similar to a file. Rewind, seek, change bytes etc. 9 | 10 | 11 | -------------------------------------------------------------------------------- /bin2cpp_memfile/extract_image.cpp: -------------------------------------------------------------------------------- 1 | #include"memfile.hpp" 2 | #include"image_res/floyd.h" 3 | 4 | 5 | int main(int argc, char **argv) { 6 | 7 | mem::binOutputArray("floyd.jpg", floyd_jpg, floyd_jpg_length); 8 | 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /bin2cpp_memfile/image_res/floyd.h: -------------------------------------------------------------------------------- 1 | #ifndef floyd_jpg__H 2 | #define floyd_jpg__H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | extern unsigned char floyd_jpg[]; 9 | extern unsigned long floyd_jpg_length; 10 | 11 | #ifdef __cplusplus 12 | } 13 | #endif 14 | 15 | 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /bin2cpp_memfile/memfile_demo.cpp: -------------------------------------------------------------------------------- 1 | #include"memfile.hpp" 2 | #include 3 | #include"resource/resource.h" 4 | 5 | 6 | int main(int argc, char **argv) { 7 | mem::MemFile file, bfile; 8 | // open from exisiting file 9 | if(!file.open("./memfile_demo.cpp")) { 10 | std::cerr << "Could not open file: \n"; 11 | exit(EXIT_FAILURE); 12 | } 13 | // loop read each byte 14 | while(!file.eof()) { 15 | char b; 16 | file.read(&b, 1); 17 | std::cout << b; 18 | } 19 | // close file 20 | file.close(); 21 | 22 | mem::binOutputArray("file.txt", memfile_hpp, memfile_hpp_length); 23 | 24 | // open memory 25 | if(!bfile.open(memfile_hpp, memfile_hpp_length)) { 26 | std::cerr << "Could not open byte stream..\n"; 27 | exit(EXIT_FAILURE); 28 | } 29 | // replace first character with an @ 30 | char c = '@'; 31 | bfile.write(&c, 1); 32 | // rewind to begining 33 | bfile.rewind(); 34 | // loop and read each character 35 | while(!bfile.eof()) { 36 | char b; 37 | bfile.read(&b, 1); 38 | std::cout << b; 39 | } 40 | // close memory file 41 | bfile.close(); 42 | return EXIT_SUCCESS; 43 | } 44 | -------------------------------------------------------------------------------- /bin2cpp_memfile/resource/resource.h: -------------------------------------------------------------------------------- 1 | #ifndef memfile_hpp__H 2 | #define memfile_hpp__H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | extern unsigned char memfile_hpp[]; 9 | extern unsigned long memfile_hpp_length; 10 | 11 | #ifdef __cplusplus 12 | } 13 | #endif 14 | 15 | 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /bin_to_array/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS=-std=c++11 3 | OUTPUT_FILE=bin2cpp 4 | 5 | all: $(OUTPUT_FILE) 6 | 7 | $(OUTPUT_FILE): $(OUTPUT_FILE).cpp 8 | $(CXX) $(CXX_FLAGS) $(OUTPUT_FILE).cpp -o $(OUTPUT_FILE) 9 | clean: 10 | rm -f $(OUTPUT_FILE) 11 | install: 12 | cp $(OUTPUT_FILE) /usr/local/bin 13 | -------------------------------------------------------------------------------- /bin_to_array/bin2cpp.cpp.h: -------------------------------------------------------------------------------- 1 | #ifndef bin2cpp_cpp__H 2 | #define bin2cpp_cpp__H 3 | 4 | extern "C" { 5 | 6 | extern unsigned char bin2cpp_cpp[]; 7 | 8 | } 9 | 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /bin_to_array/test/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | BIN2CPP=bin2cpp 3 | CXX_FLAGS=-std=c++11 4 | SOURCE=test.cpp 5 | 6 | all: 7 | $(BIN2CPP) $(SOURCE) 8 | $(CXX) $(CXX_FLAGS) $(SOURCE) -c -o test.o 9 | $(CXX) $(CXX_FLAGS) $(SOURCE).cpp -c -o test_cpp.o 10 | $(CXX) $(CXX_FLAGS) test.o test_cpp.o -o test-program 11 | clean: 12 | rm -f *.o test-program 13 | -------------------------------------------------------------------------------- /bin_to_array/test/test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include"test.cpp.h" 4 | 5 | 6 | int main(int argc, char **argv) { 7 | std::cout << "EMBEDDED TEXT: \n"; 8 | std::cout << test_cpp << "\n"; 9 | return 0; 10 | } -------------------------------------------------------------------------------- /bin_to_array/test/test.cpp.h: -------------------------------------------------------------------------------- 1 | #ifndef test_cpp__H 2 | #define test_cpp__H 3 | 4 | extern "C" { 5 | 6 | extern unsigned char test_cpp[]; 7 | 8 | } 9 | 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /bitmask/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: mask-test 4 | 5 | mask-test: mask.cpp 6 | $(CXX) $(CXX_FLAGS) mask.cpp -o mask-test 7 | 8 | clean: 9 | rm -f mask-test 10 | -------------------------------------------------------------------------------- /bitmask/mask.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int OPTION_1 = 0x1, OPTION_2 = 0x2, OPTION_3 = 0x4, OPTION_4 = 0x8; 5 | 6 | void printOptions(const int &i) { 7 | if((i & OPTION_1) != 0) { 8 | std::cout << "Option 1..\n"; 9 | } 10 | 11 | if((i & OPTION_2) != 0) { 12 | std::cout << "Option 2..\n"; 13 | } 14 | 15 | 16 | if((i & OPTION_3) != 0) { 17 | std::cout << "Option 3..\n"; 18 | } 19 | 20 | if((i & OPTION_4) != 0) { 21 | std::cout << "Option 4..\n"; 22 | } 23 | } 24 | 25 | int main(int argc, char **argv) { 26 | std::cout << "Mask #1: "; 27 | printOptions(OPTION_1 | OPTION_4); 28 | std::cout << "Mask #2: "; 29 | printOptions(OPTION_2 | OPTION_3); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /bitset/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -Wall -std=c++11 3 | 4 | all: bitset-test 5 | 6 | bitset-test: bitset_test.cc 7 | $(CXX) bitset_test.cc -o bitset-test $(FLAGS) 8 | clean: 9 | rm -f bitset-test 10 | -------------------------------------------------------------------------------- /bitset/bitset_test.cc: -------------------------------------------------------------------------------- 1 | /* 2 | Written by Jared Bruni 3 | http://lostsidedead.com 4 | bitset ecapsulates bits 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | template 12 | std::bitset reverse_value(std::bitset &value) { 13 | std::bitset rev; 14 | 15 | for(unsigned int i = 0; i < value.size(); ++i) 16 | rev[(N-1)-i] = value[i]; 17 | 18 | return rev; 19 | } 20 | 21 | int main(int argc, char **argv) { 22 | 23 | std::bitset<32> bit_value = 0x0F0F0F0F; 24 | std::bitset<32> rev_value; 25 | 26 | rev_value = reverse_value(bit_value); 27 | 28 | std::cout << std::setw(12) << "orig value: "; 29 | std::cout << std::setw(32) << bit_value << "\n"; 30 | std::cout << std::setw(12) << "reversed: "; 31 | std::cout << std::setw(32) << rev_value << "\n"; 32 | 33 | return 0; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /boost/asio/async_server/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | BOOST_DIR=/opt/local/boost 3 | FLAGS= -std=c++11 -I$(BOOST_DIR)/include 4 | FILES=server.o 5 | LDFLAGS= -L$(BOOST_DIR)/lib -lboost_system 6 | 7 | all: 8 | $(CXX) $(FLAGS) server.cpp -c -o server.o 9 | $(CXX) $(FLAGS) $(FILES) -o asynctest-server $(LDFLAGS) 10 | $(CXX) $(FLAGS) client.cpp -o asynctest-client $(LDFLAGS) 11 | clean: 12 | rm -f asynctest-client asynctest-server *.o 13 | -------------------------------------------------------------------------------- /boost/asio/download/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | BOOST_DIR=/opt/local/boost 3 | FLAGS= -std=c++11 -I$(BOOST_DIR)/include 4 | FILES=filesend.o main.o 5 | LDFLAGS= -L$(BOOST_DIR)/lib -lboost_system 6 | 7 | all: 8 | $(CXX) $(FLAGS) download.cpp -o download-test $(LDFLAGS) 9 | clean: 10 | rm -f download-test 11 | -------------------------------------------------------------------------------- /boost/asio/ex1/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | BOOST_DIR=/opt/local/boost 3 | FLAGS= -std=c++11 -I$(BOOST_DIR)/include 4 | FILES=filesend.o main.o 5 | LDFLAGS= -L$(BOOST_DIR)/lib -lboost_system 6 | 7 | all: 8 | $(CXX) $(FLAGS) filesend.cpp -c -o filesend.o 9 | $(CXX) $(FLAGS) main.cpp -c -o main.o 10 | $(CXX) $(FLAGS) $(FILES) -o bfilesend $(LDFLAGS) 11 | $(CXX) $(FLAGS) server.cpp -o programtest $(LDFLAGS) 12 | clean: 13 | rm -f bfilesend programtest *.o 14 | -------------------------------------------------------------------------------- /boost/asio/ex1/filesend.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/boost/asio/ex1/filesend.cpp -------------------------------------------------------------------------------- /boost/asio/ex1/filesend.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __FILESEND_H__ 2 | #define __FILESEND_H__ 3 | 4 | #include 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | #endif 13 | 14 | 15 | -------------------------------------------------------------------------------- /boost/asio/ex1/main.cpp: -------------------------------------------------------------------------------- 1 | // modified example from boost.org 2 | 3 | #include 4 | #include"filesend.hpp" 5 | #include 6 | 7 | using boost::asio::ip::tcp; 8 | 9 | int main(int argc, char **argv) { 10 | try { 11 | if(argc != 2) { 12 | std::cerr << "Error requires one argument.\n"; 13 | return 1; 14 | } 15 | boost::asio::io_service io_service; 16 | tcp::resolver resolver(io_service); 17 | tcp::resolver::query query(argv[1], "10241"); 18 | tcp::resolver::iterator endpoint_iterator = resolver.resolve(query); 19 | tcp::socket socket(io_service); 20 | boost::asio::connect(socket, endpoint_iterator); 21 | while(1) { 22 | boost::array buf; 23 | boost::system::error_code error; 24 | size_t len = socket.read_some(boost::asio::buffer(buf), error); 25 | if(error == boost::asio::error::eof) 26 | break; 27 | else if(error) 28 | throw boost::system::system_error(error); 29 | 30 | std::cout.write(buf.data(), len); 31 | } 32 | } catch(std::exception &e) { 33 | std::cerr << e.what() << "\n"; 34 | } 35 | return 0; 36 | } -------------------------------------------------------------------------------- /boost/asio/ex1/server.cpp: -------------------------------------------------------------------------------- 1 | 2 | // modified example from boost.org 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using boost::asio::ip::tcp; 10 | 11 | std::string randomString() { 12 | std::ostringstream stream; 13 | stream << "Hello World Your Random Number is: " << (rand()%255) << "\n"; 14 | return stream.str(); 15 | } 16 | 17 | int main(int argc, char **argv) 18 | { 19 | try { 20 | boost::asio::io_service io_service; 21 | tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 10241)); 22 | 23 | while(1) { 24 | tcp::socket socket(io_service); 25 | acceptor.accept(socket); 26 | std::string message = randomString(); 27 | boost::system::error_code ignored_error; 28 | boost::asio::write(socket, boost::asio::buffer(message), ignored_error); 29 | } 30 | } 31 | catch (std::exception& e) { 32 | std::cerr << e.what() << std::endl; 33 | } 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /boost/asio/filesend/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | BOOST_DIR=/opt/local/boost 3 | FLAGS= -std=c++11 -I$(BOOST_DIR)/include 4 | FILES=filesend.o main.o 5 | LDFLAGS= -L$(BOOST_DIR)/lib -lboost_system 6 | 7 | all: 8 | $(CXX) $(FLAGS) filesend.cpp -c -o filesend.o 9 | $(CXX) $(FLAGS) main.cpp -c -o main.o 10 | $(CXX) $(FLAGS) $(FILES) -o getfile $(LDFLAGS) 11 | $(CXX) $(FLAGS) server.cpp filesend.cpp -o servtest $(LDFLAGS) 12 | clean: 13 | rm -f getfile servtest *.o 14 | -------------------------------------------------------------------------------- /boost/asio/filesend/filesend.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __FILESEND_H__ 2 | #define __FILESEND_H__ 3 | 4 | #include 5 | 6 | using boost::asio::ip::tcp; 7 | 8 | extern bool sendFile(tcp::socket &socket, std::string filepath); 9 | extern bool recvFile(tcp::socket &socket, std::string filepath); 10 | 11 | #endif 12 | 13 | 14 | -------------------------------------------------------------------------------- /boost/asio/filesend/main.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include"filesend.hpp" 4 | #include 5 | 6 | using boost::asio::ip::tcp; 7 | 8 | int main(int argc, char **argv) { 9 | try { 10 | if(argc != 3) { 11 | std::cerr << "Error requires two arguments: host filename \n"; 12 | return 1; 13 | } 14 | boost::asio::io_service io_service; 15 | tcp::resolver resolver(io_service); 16 | tcp::resolver::query query(argv[1], "10241"); 17 | tcp::resolver::iterator endpoint_iterator = resolver.resolve(query); 18 | tcp::socket socket(io_service); 19 | boost::asio::connect(socket, endpoint_iterator); 20 | if(recvFile(socket, argv[2]) == false) { 21 | std::cerr << "Failed reading file.\n"; 22 | } else std::cout << "File read.\n"; 23 | 24 | } catch(std::exception &e) { 25 | std::cerr << e.what() << "\n"; 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /boost/asio/filesend/server.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include"filesend.hpp" 7 | 8 | using boost::asio::ip::tcp; 9 | 10 | int main(int argc, char **argv) 11 | { 12 | try { 13 | boost::asio::io_service io_service; 14 | tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 10241)); 15 | 16 | while(1) { 17 | tcp::socket socket(io_service); 18 | acceptor.accept(socket); 19 | if(sendFile(socket, argv[1]) == false) { 20 | std::cerr << "Failed to send file.\n"; 21 | } else std::cout << "Success file sent.\n"; 22 | } 23 | } 24 | catch (std::exception& e) { 25 | std::cerr << e.what() << std::endl; 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /boost/asio/fileserv/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | BOOST_DIR=/opt/local/boost 3 | FLAGS= -std=c++11 -I$(BOOST_DIR)/include 4 | FILES=file-server.o 5 | LDFLAGS= -L$(BOOST_DIR)/lib -lboost_system 6 | 7 | all: 8 | $(CXX) $(FLAGS) file-server.cpp -c -o file-server.o 9 | $(CXX) $(FLAGS) $(FILES) -o fileserv $(LDFLAGS) 10 | clean: 11 | rm -f *.o fileserv 12 | -------------------------------------------------------------------------------- /boost/asio/whiteboard/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | BOOST_PATH=/opt/local/boost 3 | CXX_FLAGS= -std=c++11 `sdl-config --cflags` -I$(BOOST_PATH)/include 4 | LD_FLAGS= -L/opt/local/lib /opt/local/lib/libSDLmain.a -Wl,-framework,AppKit /opt/local/lib/libSDL.a -L/opt/local/lib /opt/local/lib/libX11.a /opt/local/lib/libX11-xcb.a /opt/local/lib/libxcb.a /opt/local/lib/libXau.a /opt/local/lib/libXdmcp.a /opt/local/lib/libXext.a /opt/local/lib/libXrandr.a /opt/local/lib/libXrender.a -Wl,-framework,OpenGL -Wl,-framework,Cocoa -Wl,-framework,ApplicationServices -Wl,-framework,Carbon -Wl,-framework,AudioToolbox -Wl,-framework,AudioUnit -Wl,-framework,IOKit -L$(BOOST_PATH)/lib /opt/local/boost/lib/libboost_system.a 5 | 6 | all: 7 | $(CXX) $(CXX_FLAGS) whiteboard.cpp -o whiteboard $(LD_FLAGS) 8 | clean: 9 | rm -f whiteboard 10 | -------------------------------------------------------------------------------- /boost/asio/whiteboard/WhiteBoard.app.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/boost/asio/whiteboard/WhiteBoard.app.zip -------------------------------------------------------------------------------- /calculator/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -Wall -std=c++11 2 | 3 | all: expr-test 4 | 5 | expr-test: main.cpp 6 | $(CXX) $(CXX_FLAGS) main.cpp -o expr-test 7 | clean: 8 | rm -rf expr-test 9 | -------------------------------------------------------------------------------- /cast/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -std=c++11 -O2 3 | 4 | all: cast-test 5 | 6 | cast-test: casttest.cc 7 | $(CXX) $(FLAGS) casttest.cc -o cast-test 8 | clean: 9 | rm -f cast-test 10 | -------------------------------------------------------------------------------- /cgi/Makefile: -------------------------------------------------------------------------------- 1 | all: sourcetest 2 | 3 | sourcetest: sourcefile.cpp 4 | g++ sourcefile.cpp -o sourcetest 5 | chmod 755 sourcetest 6 | clean: 7 | rm -f sourcetest 8 | -------------------------------------------------------------------------------- /cgi/sourcefile.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | std::string urldecode(std::string text); 8 | 9 | int main(int argc, char **argv) { 10 | std::cout << "Content-type: text/html\n\n"; 11 | std::cout << "hello world\n"; 12 | std::string txt=""; 13 | char *data = getenv("QUERY_STRING"); 14 | ///std::cout << data << "\n"; 15 | std::cout << urldecode(data) << "\n"; 16 | 17 | return 0; 18 | } 19 | 20 | std::string urldecode(std::string text) { 21 | std::ostringstream stream; 22 | for(unsigned int i = 0; i < text.length(); ++i) { 23 | if(text[i] == '+') { 24 | stream << " "; 25 | continue; 26 | } 27 | if(text[i] == '%') { 28 | if(i+2 < text.length()) { 29 | ++i; 30 | std::string test; 31 | test += text[i]; 32 | ++i; 33 | test += text[i]; 34 | int char_value; 35 | sscanf(test.c_str(), "%x", &char_value); 36 | stream << (char)char_value; 37 | continue; 38 | } 39 | } 40 | stream << text[i]; 41 | } 42 | return stream.str(); 43 | } 44 | -------------------------------------------------------------------------------- /cgi/tokenize-c++/Makefile: -------------------------------------------------------------------------------- 1 | CXXFLAGS=-O2 2 | 3 | all: cpp_tokenize 4 | 5 | cpp_tokenize: sourcefile.cpp 6 | $(CXX) $(CXXFLAGS) sourcefile.cpp -o cpp_tokenize 7 | chmod 755 cpp_tokenize 8 | clean: 9 | rm -f cpp_tokenize 10 | -------------------------------------------------------------------------------- /cgi/tokenize-c++/test.txt: -------------------------------------------------------------------------------- 1 | helloworld("test"); 2 | 3 | -------------------------------------------------------------------------------- /chrono/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -Wall -std=c++11 3 | 4 | all: time-test scoped-test looptest-test 5 | 6 | time-test: timetest.cc 7 | $(CXX) timetest.cc -o time-test $(FLAGS) 8 | scoped-test: scoped_t.cc 9 | $(CXX) scoped_t.cc -o scoped-test $(FLAGS) 10 | looptest-test: looptest.cc 11 | $(CXX) looptest.cc -o looptest-test $(FLAGS) 12 | clean: 13 | rm -f time-test scoped-test looptest-test 14 | -------------------------------------------------------------------------------- /chrono/scoped_t.cc: -------------------------------------------------------------------------------- 1 | /* 2 | written by Jared Bruni 3 | http://lostsidedead.com 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | 10 | class ScopedTime { 11 | public: 12 | std::chrono::high_resolution_clock::time_point time_start; 13 | ScopedTime(); 14 | ~ScopedTime(); 15 | }; 16 | 17 | ScopedTime::ScopedTime(){ 18 | time_start = std::chrono::high_resolution_clock::now(); 19 | } 20 | 21 | ScopedTime::~ScopedTime() { 22 | auto now = std::chrono::high_resolution_clock::now(); 23 | std::cout << "Object was alive for : " << std::chrono::duration_cast(now-time_start).count() << " nanoseconds\n"; 24 | } 25 | 26 | int main(int argc, char **argv) { 27 | 28 | // lets see how long these loops take. 29 | 30 | ScopedTime value_wait; 31 | for(unsigned int i = 0; i < 100; ++i) { 32 | for(unsigned int i = 0; i < 100; ++i) { 33 | ScopedTime inner_loop; 34 | for(unsigned z = 0; z < 10000; ++z) { } 35 | } 36 | } 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /chrono/timetest.cc: -------------------------------------------------------------------------------- 1 | /* 2 | written by Jared Bruni 3 | http://lostsidedead.com 4 | 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | template 11 | void WasteTime() { 12 | for(size_t i = 0; i < X; ++i) { 13 | for(size_t z = 0; z < Y; ++z) { 14 | std::cout << "Waste some time " << i << ":" << z << " \n"; 15 | } 16 | } 17 | } 18 | 19 | int main(int argc, char **argv) { 20 | using namespace std; 21 | auto n1 = chrono::high_resolution_clock::now(); 22 | WasteTime<400, 400>(); 23 | auto n2 = chrono::high_resolution_clock::now(); 24 | 25 | std::cout << "Operation WasteTime took " << chrono::duration_cast(n2-n1).count() << " milliseconds\n"; 26 | 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /compile_test/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS= -std=c++11 -O2 3 | 4 | all: compile-test 5 | 6 | compile-test: compile-test.cpp 7 | $(CXX) $(CXX_FLAGS) compile-test.cpp -o compile-test 8 | clean: 9 | rm -f compile-test 10 | -------------------------------------------------------------------------------- /compile_test/Makefile.mingw: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | LD_FLAGS= -static-libgcc -static-libstdc++ 3 | CXX=x86_64-w64-mingw32-g++ 4 | 5 | all: compile-test 6 | 7 | compile-test: compile-test.cpp 8 | $(CXX) $(CXX_FLAGS) compile-test.cpp -o compile-test.exe $(LD_FLAGS) 9 | clean: 10 | rm -f compile-test 11 | -------------------------------------------------------------------------------- /compile_test/compile-test: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/compile_test/compile-test -------------------------------------------------------------------------------- /compile_test/compile-test.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/compile_test/compile-test.exe -------------------------------------------------------------------------------- /compress_code/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 -O2 2 | 3 | all: compress-code format-code 4 | 5 | compress-code: main.cpp 6 | $(CXX) $(CXX_FLAGS) main.cpp -o compress-code 7 | format-code: format.cpp 8 | $(CXX) $(CXX_FLAGS) format.cpp -o format-code 9 | clean: 10 | rm -f compress-code format-code 11 | -------------------------------------------------------------------------------- /compress_code/compress-code: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/compress_code/compress-code -------------------------------------------------------------------------------- /constexpr/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS=-Wall -std=c++11 3 | all: constexpr-test constexpr-test2 constexpr-test3 4 | constexpr-test: constexpr.cc 5 | $(CXX) $(FLAGS) constexpr.cc -o constexpr-test 6 | constexpr-test2: constexpr-test.cc 7 | $(CXX) $(FLAGS) constexpr-test.cc -o constexpr-test2 8 | constexpr-test3: constexpr_example.cpp 9 | $(CXX) $(FLAGS) constexpr_example.cpp -o constexpr-test3 10 | clean: 11 | rm -f constexpr-test constexpr-test2 constexpr-test3 12 | -------------------------------------------------------------------------------- /constexpr/constexpr-test.cc: -------------------------------------------------------------------------------- 1 | /* written by Jared Bruni 2 | http:// lostsidedead.com 3 | */ 4 | 5 | 6 | #include 7 | #include 8 | 9 | 10 | template 11 | class Con { 12 | public: 13 | // constexpr constructor is called a literal type. To be simple enough to be 14 | // constexpr a constructor must have a empty body. 15 | // Section 10.4.3 C++ Programming Language 4th Edition 16 | constexpr Con() {} 17 | 18 | constexpr static T square(const T val) { return val*val; } 19 | 20 | static_assert(sizeof(T)<=4, "Larger than 4 bytes.\n"); 21 | static_assert(std::is_arithmetic::value,"Is not numeric"); 22 | }; 23 | 24 | constexpr int v1 = 10; 25 | constexpr int v2 = 20; 26 | 27 | constexpr Con v; 28 | constexpr int value=v.square(v1*v2); 29 | int arr[value]; 30 | 31 | 32 | int main(int argc, char **argv) { 33 | // below would not pass static_assert 34 | // Con v2; 35 | std::cout << " Size of array is: " << value << "\n"; 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /constexpr/constexpr.cc: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Jared Bruni on 7/9/13. 3 | // 4 | 5 | #include 6 | 7 | constexpr int calcNum(int num) { 8 | return (num/2)/16; 9 | } 10 | 11 | constexpr int Calc = calcNum(400); 12 | int arr_temp[Calc]; // note constexpr 13 | 14 | 15 | //another 16 | 17 | template 18 | class ArrTile { 19 | public: 20 | T type[calcNum(Num)]; // note constexpr 21 | 22 | T &operator[](unsigned int i) { return type[i]; } 23 | }; 24 | 25 | 26 | int main(int argc, char **argv) 27 | { 28 | ArrTile arrTile; 29 | arrTile[0] = 0; 30 | 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /databyte/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS=-std=c++11 3 | 4 | all: data-test 5 | 6 | data-test: main.cpp 7 | $(CXX) $(CXX_FLAGS) main.cpp -o data-test 8 | clean: 9 | rm -f data-test 10 | -------------------------------------------------------------------------------- /databyte/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include"databytes.hpp" 3 | 4 | int main(int argc, char **argv) { 5 | 6 | 7 | unsigned int index = 0xFFFFFFFF; 8 | 9 | DataByte value(index); 10 | 11 | for(unsigned int i = 0; i < value.size(); ++i) { 12 | std::cout << "index: " << i << " value: " << (unsigned int)value[i] << "\n"; 13 | } 14 | 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /db/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS=-std=c++11 -Wall 2 | 3 | all: db-test 4 | 5 | db-test: db.cpp 6 | $(CXX) db.cpp -o db-test $(FLAGS) 7 | clean: 8 | rm -f db-test 9 | -------------------------------------------------------------------------------- /download/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS= -Wall -std=c++11 2 | 3 | all: dl-test 4 | 5 | dl-test: main.cpp 6 | $(CXX) $(FLAGS) main.cpp -o dl-test -pthread 7 | clean: 8 | rm -f dl-test 9 | -------------------------------------------------------------------------------- /enum/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -std=c++11 -Wall 3 | all: enum-test ec-test 4 | 5 | enum-test: enum.cc 6 | $(CXX) enum.cc -o enum-test $(FLAGS) 7 | ec-test: enum_class.cpp 8 | $(CXX) enum_class.cpp -o ec-test $(FLAGS) 9 | clean: 10 | rm -f enum-test ec-test 11 | -------------------------------------------------------------------------------- /enum/enum.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char **argv) { 4 | enum Value { one=1, two, three }; 5 | enum class StrongValue { s_one, s_two, s_three }; 6 | StrongValue sv = StrongValue::s_one; 7 | Value v = one; 8 | int x = v; 9 | // error line below wont compile. 10 | //int y = StrongValue::s_three; 11 | std::cout << "Value is: " << x << "\n"; 12 | sv = StrongValue::s_two; 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /enum/enum_class.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | enum class Value_type { type1, type2, type3 }; 4 | 5 | int main() { 6 | 7 | Value_type type1 = Value_type::type1; 8 | 9 | if(type1 != Value_type::type2) { 10 | std::cout << "Not a type 2.\n"; 11 | } 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /finally/Makefile: -------------------------------------------------------------------------------- 1 | 2 | all: finally-test 3 | 4 | finally-test: finally.cc 5 | $(CXX) -Wall finally.cc -o finally-test -std=c++11 6 | clean: 7 | rm -f finally-test 8 | -------------------------------------------------------------------------------- /find/Makefile: -------------------------------------------------------------------------------- 1 | CXXFLAGS=-std=c++11 2 | SOURCE=find.cpp 3 | OUTPUT=find-test 4 | 5 | all: $(OUTPUT) 6 | 7 | $(OUTPUT): $(SOURCE) 8 | $(CXX) $(CXXFLAGS) $(SOURCE) -o $(OUTPUT) 9 | clean: 10 | rm -f $(OUTPUT) 11 | -------------------------------------------------------------------------------- /find/find.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | std::vector values; 6 | 7 | 8 | int main() { 9 | 10 | for(unsigned int i = 0; i < 500; ++i) { 11 | values.push_back(rand()%100); 12 | } 13 | 14 | auto it = std::find(values.begin(), values.end(), 57); 15 | 16 | if(it != values.end()) { 17 | std::cout << "Found 57 in values\n"; 18 | } 19 | else { 20 | std::cout << "Did not find 57..\n"; 21 | } 22 | 23 | std::string text; 24 | std::cin >> text; 25 | 26 | if(text.find("e") != -1) { 27 | std::cout << "You typed a e.\n"; 28 | } 29 | else { 30 | std::cout << "You didn't type a e.\n"; 31 | } 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /friend/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -Wall -std=c++11 3 | 4 | all: friend-test 5 | 6 | friend-test: friend_test.cc 7 | $(CXX) friend_test.cc -o friend-test $(FLAGS) 8 | clean: 9 | rm -f friend-test 10 | -------------------------------------------------------------------------------- /fstream/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS= -std=c++11 -O2 2 | 3 | all: readwrite-test text-test 4 | 5 | readwrite-test: readwrite.cc 6 | $(CXX) $(FLAGS) readwrite.cc -o readwrite-test 7 | text-test: textoutput.cc 8 | $(CXX) $(FLAGS) textoutput.cc -o text-test 9 | clean: 10 | rm -f readwrite-test text-test 11 | -------------------------------------------------------------------------------- /function_objects/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: func1-test func2-test 4 | 5 | func1-test: func1.cpp 6 | $(CXX) $(CXX_FLAGS) func1.cpp -o func1-test -pthread 7 | func2-test: func2.cpp 8 | $(CXX) $(CXX_FLAGS) func2.cpp -o func2-test -pthread 9 | clean: 10 | rm -f func1-test func2-test 11 | 12 | -------------------------------------------------------------------------------- /function_objects/func1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | template 7 | class ForEach_Function { 8 | public: 9 | // pass in needed variables here 10 | ForEach_Function(std::string t) : text(t) { 11 | 12 | } 13 | // overload () operator 14 | void operator()(const T& type) { 15 | std::cout << text << " " << type << "\n"; 16 | } 17 | 18 | private: 19 | std::string text; 20 | }; 21 | 22 | 23 | int main() { 24 | std::vector vec1 {"jared", "bruni", "LostSideDead"}; 25 | // initalize function object 26 | ForEach_Function fobject("Vector of type string"); 27 | // use function object 28 | std::for_each(vec1.begin(), vec1.end(), fobject); 29 | 30 | std::vector vec2{0, 1999, 2015, 360}; 31 | // initalize function object 32 | ForEach_Function fiobject("Vector of type int"); 33 | // use function object 34 | std::for_each(vec2.begin(), vec2.end(), fiobject); 35 | return 0; 36 | } -------------------------------------------------------------------------------- /function_objects/func2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | std::mutex lmutex; 8 | 9 | class ThreadObject { 10 | public: 11 | ThreadObject(std::string thread_name) : name(thread_name) {} 12 | void operator()() { 13 | for(unsigned int i = 0; i < 100; ++i) { 14 | lmutex.lock(); 15 | std::cout << name << ": " << i << "\n"; 16 | lmutex.unlock(); 17 | } 18 | } 19 | private: 20 | std::string name; 21 | }; 22 | 23 | int main() { 24 | ThreadObject thread1("thread one"), thread2 ("thread two"), thread3("thread three"); 25 | std::thread t1(thread1), t2(thread2), t3(thread3); 26 | t1.join(); 27 | t2.join(); 28 | t3.join(); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /function_syntax/Makefile: -------------------------------------------------------------------------------- 1 | 2 | 3 | all: func-test func-test1 4 | func-test: function_syntax.cc 5 | $(CXX) -Wall function_syntax.cc -o func-test -std=c++11 6 | func-test1: test1.cc 7 | $(CXX) -Wall test1.cc -o func-test1 -std=c++11 8 | clean: 9 | rm -f func-test1 func-test 10 | -------------------------------------------------------------------------------- /function_syntax/test1.cc: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | 6 | class MemberFunctionSyntax { 7 | 8 | public: 9 | auto function_name(int x, int y) -> decltype(x) { 10 | return x+y; 11 | } 12 | template 13 | auto function_name(T &t) -> decltype(t) { 14 | return t+t; 15 | } 16 | }; 17 | 18 | 19 | // alternate function decl syntax 20 | auto function_def(int x, int y) -> int { 21 | 22 | // lambda 23 | auto func_def = [](int x, int y) -> int { 24 | return x+y; 25 | }; 26 | 27 | return func_def(x,y); 28 | } 29 | 30 | auto main(int argc, char **argv) -> int { 31 | std::cout << "Hello World\n"; 32 | return 0; 33 | } -------------------------------------------------------------------------------- /generic/Makefile: -------------------------------------------------------------------------------- 1 | 2 | FLAGS=-Wall -std=c++11 3 | 4 | all: temp1-test temp2-test 5 | 6 | temp1-test: temp1.cc 7 | $(CXX) temp1.cc -o temp1-test $(FLAGS) 8 | temp2-test: temp2.cc 9 | $(CXX) temp2.cc -o temp2-test $(FLAGS) 10 | clean: 11 | rm -f temp1-test temp2-test 12 | -------------------------------------------------------------------------------- /hash/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS=-std=c++11 -Wall 3 | 4 | all: hash1-test hash2-test hash3-test 5 | 6 | hash1-test: hash1.cpp 7 | $(CXX) hash1.cpp -o hash1-test $(CXX_FLAGS) 8 | hash2-test: hash2.cpp 9 | $(CXX) hash2.cpp -o hash2-test $(CXX_FLAGS) 10 | hash3-test: hash3.cpp 11 | $(CXX) hash3.cpp -o hash3-test $(CXX_FLAGS) 12 | 13 | clean: 14 | rm -f hash1-test hash2-test hash3-test 15 | -------------------------------------------------------------------------------- /hero/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXXFLAGS= -std=c++11 -O2 3 | SOURCE=main.cc 4 | 5 | all: test-prog 6 | 7 | test-prog: main.cc 8 | $(CXX) $(CXXFLAGS) -o test-prog $(SOURCE) 9 | clean: 10 | rm -f test-prog 11 | 12 | -------------------------------------------------------------------------------- /hero/main.cc: -------------------------------------------------------------------------------- 1 | #include"hero.hpp" 2 | #include 3 | 4 | 5 | int main(int argc, char **argv) { 6 | 7 | 8 | 9 | game::Hero hero(0, 0); 10 | 11 | std::cout << "Hero starting position: " << hero.toString() << "\n"; 12 | 13 | hero.move(game::DIRECTION_RIGHT); 14 | 15 | std::cout << "Hero Position after moving right: " << hero.toString() << "\n"; 16 | 17 | hero.move(game::DIRECTION_DOWN); 18 | 19 | std::cout << "New Hero Position after moving down: " << hero.toString() << "\n"; 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /idea/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 -Wall 2 | 3 | all: love-test 4 | 5 | 6 | love-test: love.cpp 7 | $(CXX) $(CXX_FLAGS) love.cpp -o love-test -pthread 8 | clean: 9 | rm -f love-test 10 | 11 | -------------------------------------------------------------------------------- /init/Makefile: -------------------------------------------------------------------------------- 1 | 2 | FLAGS=-std=c++11 -Wall 3 | all: init-test init-test2 4 | 5 | init-test: init_list.cc 6 | $(CXX) init_list.cc -o init-test $(FLAGS) 7 | init-test2: init_test.cpp 8 | $(CXX) init_test.cpp -o init-test2 $(FLAGS) 9 | clean: 10 | rm -f init-test init-test2 11 | -------------------------------------------------------------------------------- /init/init_list.cc: -------------------------------------------------------------------------------- 1 | /* Wrapper using Initializer List */ 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | template 10 | class VectorWrapper { 11 | public: 12 | VectorWrapper() { } 13 | VectorWrapper(std::initializer_list il) : v{il} { 14 | std::cout << "Wrapper Started..\n"; 15 | } 16 | void addTo(T type) { 17 | // do something before adding to v 18 | v.push_back(type); 19 | } 20 | std::vector &cont() { return v; } 21 | protected: 22 | std::vector v; 23 | }; 24 | 25 | 26 | int main(int argc, char **argv) { 27 | 28 | VectorWrapper wrap({"test ", "one", "two", "three"}); 29 | for_each(wrap.cont().begin(), wrap.cont().end(), [](std::string s) { 30 | std::cout << "Element: " << s << "\n"; 31 | }); 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /init/init_test.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | template 9 | class ArrayOf { 10 | public: 11 | void add(std::initializer_list add) { 12 | for(auto &i : add) 13 | v.push_back(i); 14 | } 15 | 16 | void printOut() { 17 | for(auto &i : v) { 18 | std::cout << i << "\n"; 19 | } 20 | } 21 | 22 | private: 23 | std::vector v; 24 | 25 | }; 26 | 27 | 28 | int main() { 29 | 30 | ArrayOf init; 31 | init.add({"One", "Two", "Three", "Four" }); 32 | init.printOut(); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /iterator/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXXFLAGS=-Wall -std=c++11 3 | 4 | all: it-test it-test2 it-test3 5 | 6 | it-test: it.cpp 7 | $(CXX) it.cpp -o it-test $(CXXFLAGS) 8 | it-test2: it2.cpp 9 | $(CXX) it2.cpp -o it-test2 $(CXXFLAGS) 10 | it-test3: it3.cpp 11 | $(CXX) it3.cpp -o it-test3 $(CXXFLAGS) 12 | clean: 13 | rm -f it-test it-test2 it-test3 14 | -------------------------------------------------------------------------------- /iterator/it3.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | written by Jared Bruni 3 | http://lostsidedead.com 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | template 10 | void LowerCase(Iter start, Iter stop) { 11 | for(Iter i = start; i != stop; ++i) { 12 | *i = tolower(*i); 13 | } 14 | } 15 | 16 | template 17 | void ApplyFunction(Iter start, Iter stop, F f) { 18 | for(Iter i = start; i != stop; ++i) { 19 | *i = f(*i); 20 | } 21 | } 22 | 23 | int main(int argc, char **argv) { 24 | 25 | 26 | std::cout << "Enter string: "; 27 | std::string s; 28 | std::cin >> s; 29 | 30 | LowerCase(s.begin(), s.end()); 31 | std::cout << "Lowercased: " << s << "\n"; 32 | 33 | ApplyFunction(s.begin(), s.end(), [](char c) { return toupper(c); }); 34 | 35 | std::cout << "Uppercased: " << s << "\n"; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /join/Makefile: -------------------------------------------------------------------------------- 1 | CXXFLAGS=-std=c++11 2 | 3 | all: join-test 4 | 5 | join-test: main.cpp 6 | $(CXX) $(CXXFLAGS) main.cpp -o join-test 7 | clean: 8 | rm -f join-test 9 | -------------------------------------------------------------------------------- /join/join.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __JOIN_H__ 2 | #define __JOIN_H__ 3 | #include 4 | #include 5 | #include 6 | 7 | template 8 | std::string join(const T &type, std::string sep=",") { 9 | std::ostringstream stream; 10 | for(auto i = std::begin(type); i != std::end(type); ++i) { 11 | if(i == std::end(type)-1) 12 | stream << *i; 13 | else 14 | stream << *i << sep; 15 | } 16 | return stream.str(); 17 | } 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /join/main.cpp: -------------------------------------------------------------------------------- 1 | #include"join.hpp" 2 | #include 3 | #include 4 | #include 5 | 6 | std::vector values { "one", "two", "three" }; 7 | std::array values_array { "C", "C++", "Objective-C", "Objective-C++" }; 8 | 9 | int main() { 10 | 11 | std::string value = join(values, ","); 12 | std::cout << value << "\n"; 13 | std::string joined_string = join(values_array,","); 14 | std::cout << joined_string << "\n"; 15 | return 0; 16 | } -------------------------------------------------------------------------------- /lambda/Makefile: -------------------------------------------------------------------------------- 1 | 2 | FLAGS= -Wall -std=c++11 3 | all: lambda_test1 lambda_test2 lambda_test3 lambda_test4 lambda_test5 lambda_test6 lambda-test7 4 | 5 | lambda_test1: lambda.cc 6 | $(CXX) lambda.cc -o lambda_test1 $(FLAGS) 7 | lambda_test2: lambda2.cc 8 | $(CXX) lambda2.cc -o lambda_test2 $(FLAGS) 9 | lambda_test3: lambda_capture.cc 10 | $(CXX) lambda_capture.cc -o lambda_test3 $(FLAGS) 11 | lambda_test4: main.cc 12 | $(CXX) main.cc -o lambda_test4 $(FLAGS) 13 | lambda_test5: source.cc 14 | $(CXX) source.cc -o lambda_test5 $(FLAGS) 15 | lambda_test6: test.cc 16 | $(CXX) test.cc -o lambda_test6 $(FLAGS) 17 | lambda-test7: lambda-test.cpp 18 | $(CXX) lambda-test.cpp -o lambda-test7 $(FLAGS) 19 | clean: 20 | rm -f lambda_test1 lambda_test2 lambda_test3 lambda_test4 lambda_test5 lambda_test6 lambda-test7 21 | -------------------------------------------------------------------------------- /lambda/lambda-test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | // container class for filter functions 5 | class FilterContainer { 6 | public: 7 | using Filter = void (*)(unsigned char *pixels); 8 | FilterContainer() = default; 9 | int addFilter(Filter f) { 10 | filters.emplace_back(f); 11 | return filters.size()-1; 12 | } 13 | void operator()(int filterID, unsigned char *pixels) { 14 | filters[filterID](pixels); 15 | } 16 | protected: 17 | std::vector filters; 18 | }; 19 | 20 | 21 | int main(int argc, char **argv) { 22 | FilterContainer f; 23 | int selfAlpha = f.addFilter( [](unsigned char *pixels) { 24 | std::cout << "selfAlphaBlend..\n"; 25 | }); 26 | int diamond = f.addFilter( [] (unsigned char *pixels) { 27 | std::cout << "diamond Pattern\n"; 28 | }); 29 | 30 | unsigned char buffer[1024]; // would be the image pixels or cv::Mat if OpenCV 31 | // call the functions through the FilterContainer interface 32 | f(selfAlpha, buffer); 33 | f(diamond, buffer); 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /lambda/lambda2.cc: -------------------------------------------------------------------------------- 1 | // example of lambda. 2 | #include 3 | #include 4 | #include 5 | 6 | int main(int argc, char **argv) { 7 | std::vector v = { 0, 4, 6, 24, 10, 7, 3, 1 }; 8 | std::for_each(v.begin(), v.end(), [](unsigned int value) { 9 | std::cout << "Current Value is: " << value << "\n"; 10 | }); 11 | std::sort(v.begin(), v.end()); 12 | for(auto &elem : v) { 13 | std::cout << "New Sorted Value is: " << elem << "\n"; 14 | } 15 | } -------------------------------------------------------------------------------- /lambda/main.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char **argv) { 5 | 6 | std::vector vec = { 2, 6, 0, 5, 7 }; 7 | 8 | int findLargest = [](std::vector &v) { 9 | int large=0; 10 | for(auto &i : v) { 11 | if(i > large) large = i; 12 | } 13 | return large; 14 | } (vec); 15 | 16 | std::cout << findLargest << "\n"; 17 | 18 | return 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /lambda/test.cc: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | class Object { 8 | 9 | public: 10 | Object() {} 11 | 12 | typedef void (*Function)(); 13 | 14 | std::map object_functions; 15 | 16 | Function &operator[](std::string func_name) { 17 | return object_functions[func_name]; 18 | } 19 | 20 | void (*update_func)(); 21 | void (*keyfunc)(int key); 22 | }; 23 | 24 | 25 | int main(int argc, char **argv) { 26 | 27 | Object obj; 28 | obj.update_func = [](){ 29 | std::cout << "UPDATE\n"; 30 | }; 31 | 32 | obj.keyfunc = [](int key){ 33 | if(key == 13) std::cout << "yes..\n"; 34 | }; 35 | 36 | obj.keyfunc(13); 37 | obj.update_func(); 38 | 39 | obj["func"] = []() { std::cout << "Hello World\n"; }; 40 | obj["func"](); 41 | int input=0; 42 | std::cin >> input; 43 | ([](int x){ for(int i = x; i < 4; ++i) std::cout << "counter: " << i << std::endl; })(input); 44 | 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /lexer/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS=-std=c++11 3 | 4 | 5 | SOURCE_FILES= mxl-test.cpp program1-test.cpp main.cpp program-test2.cpp 6 | SOURCE_OBJECTS=main.o mxl-test.o program-test1.o program-test2.o 7 | 8 | all: lexer-test mxl-test program-test1 program-test2 9 | 10 | lexer-test: main.cpp 11 | $(CXX) $(CXX_FLAGS) main.cpp -o lexer-test 12 | mxl-test: mxl-test.cpp 13 | $(CXX) $(CXX_FLAGS) mxl-test.cpp -o mxl-test 14 | program-test1: program-test1.cpp 15 | $(CXX) $(CXX_FLAGS) program-test1.cpp -o program-test1 16 | program-test2: program-test2.cpp 17 | $(CXX) $(CXX_FLAGS) program-test2.cpp -o program-test2 18 | clean: 19 | rm -f lexer-test mxl-test program-test1 program-test2 20 | install: 21 | cp lexer-test /usr/local/bin 22 | -------------------------------------------------------------------------------- /lexer/mxl-test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "mxl.hpp" 5 | #include 6 | #include 7 | 8 | int main(int argc, char **argv) { 9 | 10 | if(argc != 2) { 11 | std::cerr << "Error argument required.\n"; 12 | exit(0); 13 | } 14 | 15 | std::fstream file; 16 | file.open(argv[1], std::ios::in); 17 | if(!file.is_open()) { 18 | std::cerr << "Could not open file.\n"; 19 | exit(0); 20 | } 21 | 22 | std::unordered_map variables; 23 | mxl::MXLParser parser(file, variables); 24 | 25 | try { 26 | parser.scanSource(); 27 | std::cout << "Scanned source found: " << parser.size() << " tokens\n"; 28 | parser.procTokens(); 29 | 30 | } catch(mxl::Parser_Error &e) { 31 | e.printError(std::cerr); 32 | } catch(lex::Scanner_EOF) { 33 | 34 | } 35 | parser.outputTokens(std::cout); 36 | file.close(); 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /lexer/program-test1.cpp: -------------------------------------------------------------------------------- 1 | #include"mxl.hpp" 2 | #include 3 | #include 4 | #include 5 | 6 | 7 | 8 | int main(int argc, char **argv) { 9 | 10 | if(argc != 2) { std::cerr << "Requires 1 argument.\n"; exit(0); } 11 | 12 | try { 13 | mxl::MXLFile mxl_file(argv[1]); 14 | if(mxl_file.parse()) { 15 | mxl_file.printTags(std::cout); 16 | std::cout << "Print out just tag variable names\n"; 17 | for(auto i = mxl_file.begin(); i != mxl_file.end(); ++i) { 18 | std::cout << i->first << "\n"; 19 | } 20 | std::cout << "Adding tag\n"; 21 | mxl_file.tag_Set("Pointer", "z", "100"); 22 | std::cout << "Outputing new tag file..\n"; 23 | mxl_file.outputTags("temp.mxl"); 24 | } 25 | 26 | } catch(mxl::MXL_File_Error &e) { 27 | e.printError(std::cerr); 28 | exit(0); 29 | } 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /lexer/tags.mxl: -------------------------------------------------------------------------------- 1 | tag "Map.inner" { "Val1" = "Val2" } 2 | tag "Map.inner.second" { "tagged" = "valueof" } 3 | tag "Map" { "text" = "one" } 4 | tag "Map" { "two " = "two" } 5 | tag "Map" { "value 1" = "Value 2" } 6 | tag "Pointer" { "x" = "100" } 7 | tag "Pointer" { "y" = "200" } 8 | tag "test" { "value" = "value2" } 9 | -------------------------------------------------------------------------------- /linesort/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CFLAGS= -I.-O2 -std=c++11 3 | LDFLAGS= 4 | CPP_FILES := $(wildcard *.cpp) 5 | OBJ_FILES := $(addprefix ,$(notdir $(CPP_FILES:.cpp=.o))) 6 | 7 | %.o: %.cpp 8 | $(CXX) $(CFLAGS) -c -o $@ $< 9 | 10 | all: $(OBJ_FILES) 11 | $(CXX) $(OBJ_FILES) -o ats-dbg $(LDFLAGS) 12 | 13 | clean: 14 | rm -f ats-dbg *.o 15 | -------------------------------------------------------------------------------- /linesort/code.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __CODE_HPP__ 2 | #define __CODE_HPP__ 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include "lexer.hpp" 11 | 12 | namespace interp { 13 | 14 | class TextLine { 15 | public: 16 | TextLine(); 17 | TextLine(int index, std::string text); 18 | TextLine(const TextLine &t); 19 | bool operator<(const TextLine &t) const; 20 | bool operator==(const TextLine &t1) const; 21 | TextLine &operator=(const TextLine &t); 22 | 23 | int index; 24 | std::string text; 25 | }; 26 | 27 | class Code { 28 | public: 29 | Code() {} 30 | void clear(); 31 | }; 32 | 33 | void inputText(std::vector &tokens, std::string text); 34 | bool saveLineSource(const std::string &text); 35 | bool openLineSource(const std::string &text); 36 | void insertText(const TextLine &in); 37 | bool procLine(const TextLine &text, Code &code); 38 | 39 | extern std::vector lines; 40 | 41 | } 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /linesort/func_clear.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | namespace token { 4 | void token_Clear(std::vector &v) { 5 | if(!interp::lines.empty()) { 6 | interp::lines.erase(interp::lines.begin(), interp::lines.end()); 7 | } 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /linesort/func_convert.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | namespace token { 4 | void token_Convert(std::vector &v) { 5 | code.clear(); 6 | for(unsigned int i = 0; i < interp::lines.size(); ++i) { 7 | if(procLine(interp::lines[i], code) == false) 8 | std::cerr << "Line: " << interp::lines[i].index << " contains errors.\n"; 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /linesort/func_display.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | namespace token { 4 | void token_Display(std::vector &v) { 5 | if(v[1].getTokenType() != lex::TOKEN_DIGIT) { 6 | std::cerr << "display requires line number.\n"; 7 | return; 8 | } 9 | std::string index; 10 | index = v[1].getToken(); 11 | bool found = false; 12 | int in = atoi(index.c_str()); 13 | for(unsigned int i = 0; i < interp::lines.size(); ++i) { 14 | if(interp::lines[i].index == in) { 15 | std::cout << interp::lines[i].index << " " << interp::lines[i].text << "\n"; 16 | found = true; 17 | break; 18 | } 19 | } 20 | if(found == false) { 21 | std::cerr << "Index: " << in << " not found!\n"; } 22 | 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /linesort/func_list.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | namespace token { 4 | void token_List(std::vector &v) { 5 | for(auto i = interp::lines.begin(); i != interp::lines.end(); ++i) { 6 | std::cout << i->index << " " << i->text << "\n"; 7 | } 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /linesort/func_open.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | namespace token { 4 | void token_Open(std::vector &v) { 5 | if(v[1].getTokenType() != lex::TOKEN_STRING) { 6 | std::cerr << "open requires string operand in quotes.\n"; 7 | return; 8 | } 9 | std::string filename; 10 | filename = v[1].getToken(); 11 | if(interp::openLineSource(filename)) { 12 | std::cout << "Loaded: " << filename << "\n"; 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /linesort/func_remove.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | namespace token { 4 | void token_Remove(std::vector &v) { 5 | if(v[1].getTokenType() != lex::TOKEN_DIGIT) { 6 | std::cerr << "remove requires line number.\n"; 7 | return; 8 | } 9 | std::string index; 10 | index = v[1].getToken(); 11 | int in = atoi(index.c_str()); 12 | bool found = false; 13 | for(unsigned int i = 0; i < interp::lines.size(); ++i) { 14 | if(interp::lines[i].index == in) { 15 | interp::lines.erase(interp::lines.begin()+i); 16 | found = true; 17 | break; 18 | } 19 | } 20 | if(found == true) 21 | std::cout << "Line: " << in << " removed..\n"; 22 | else 23 | std::cerr << "Line: " << in << " not found..\n"; 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /linesort/func_save.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | namespace token { 4 | void token_Save(std::vector &v) { 5 | if(v[1].getTokenType() != lex::TOKEN_STRING) { 6 | std::cerr << "Save requires string operand in quotes.\n"; 7 | return; 8 | } 9 | std::string filename; 10 | filename = v[1].getToken(); 11 | if(interp::saveLineSource(filename)) { 12 | std::cout << "Saved: " << filename << "\n"; 13 | } 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /linesort/function.cpp: -------------------------------------------------------------------------------- 1 | #include "function.hpp" 2 | 3 | interp::Code code; 4 | 5 | namespace token { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /linesort/function.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __FUNCTION_HPP_ 2 | #define __FUNCTION_HPP_ 3 | 4 | #include 5 | #include 6 | #include 7 | #include"code.hpp" 8 | 9 | extern interp::Code code; 10 | 11 | namespace token { 12 | void token_Convert(std::vector &tokens); 13 | void token_List(std::vector &tokens); 14 | void token_Save(std::vector &tokens); 15 | void token_Open(std::vector &tokens); 16 | void token_Clear(std::vector &tokens); 17 | void token_Remove(std::vector &tokens); 18 | void token_Display(std::vector &tokens); 19 | } 20 | 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /linkedlist/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | list-test: list.cpp 4 | $(CXX) $(CXX_FLAGS) list.cpp -o list-test 5 | 6 | all: list-test 7 | 8 | clean: 9 | rm -f list-test 10 | 11 | -------------------------------------------------------------------------------- /list_to_array/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS= -std=c++11 3 | OUTPUT_FILE=list_to_array 4 | 5 | all: $(OUTPUT_FILE) 6 | 7 | $(OUTPUT_FILE): $(OUTPUT_FILE).cpp 8 | $(CXX) $(CXX_FLAGS) $(OUTPUT_FILE).cpp -o $(OUTPUT_FILE) 9 | clean: 10 | rm -f $(OUTPUT_FILE) 11 | install: 12 | cp $(OUTPUT_FILE) /usr/local/bin 13 | -------------------------------------------------------------------------------- /m3ugen/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CFLAGS= -Wall -O3 3 | 4 | 5 | all: m3ugen 6 | 7 | m3ugen: main.cc m3u.hpp 8 | $(CXX) $(CFLAGS) main.cc -o m3ugen 9 | install: all 10 | cp m3ugen /usr/local/bin 11 | clean: 12 | rm -f m3ugen 13 | -------------------------------------------------------------------------------- /m3ugen/main.cc: -------------------------------------------------------------------------------- 1 | #include"m3u.hpp" 2 | #include 3 | 4 | 5 | int main(int argc, char **argv) { 6 | 7 | if(argc != 4) { 8 | std::cout << "m3ugen directory output.m3u -s [sorted] or -r [shuffled] -n [as listed]\n"; 9 | return 0; 10 | } 11 | 12 | 13 | 14 | std::string dir_path = argv[1]; 15 | std::string output_name = argv[2]; 16 | std::vector file_list; 17 | std::vector file_types; 18 | 19 | file_types.push_back("mp3"); 20 | file_types.push_back("flac"); 21 | file_types.push_back("ogg"); 22 | file_types.push_back("wav"); 23 | int sorted = 0; 24 | if(std::string(argv[3]) == "-s") sorted = 1; 25 | if(std::string(argv[3]) == "-r") sorted = 2; 26 | 27 | if(m3u::gen_m3u_file(sorted, dir_path, output_name, file_list, file_types)) { 28 | std::cout << "Generated: " << output_name << "\n"; 29 | } 30 | 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /main/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS= -std=c++11 3 | 4 | all: testcode 5 | 6 | testcode: main.cpp 7 | $(CXX) $(CXX_FLAGS) main.cpp -o testcode 8 | clean: 9 | rm -f testcode 10 | -------------------------------------------------------------------------------- /main/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define OBJECT_MAIN(X) int main(int argc, char **argv) { return X::main(argc, argv); } 3 | 4 | class Object { 5 | 6 | void say(std::string text) { 7 | std::cout << text; 8 | } 9 | public: 10 | static int main(int argc, char **argv) { 11 | std::cout << "Hello world OO-style\n"; 12 | Object o; 13 | o.say("Hello world from Object.\n"); 14 | return 0; 15 | } 16 | }; 17 | 18 | 19 | OBJECT_MAIN(Object); -------------------------------------------------------------------------------- /member/Makefile: -------------------------------------------------------------------------------- 1 | 2 | all: member-test 3 | 4 | member-test: memberdecl.cc 5 | $(CXX) -Wall memberdecl.cc -o member-test -std=c++11 6 | clean: 7 | rm -f member-test 8 | -------------------------------------------------------------------------------- /member/memberdecl.cc: -------------------------------------------------------------------------------- 1 | // 2 | // Member 3 | // 4 | // Created by Jared Bruni on 7/9/13. 5 | 6 | 7 | #include 8 | 9 | enum class Direction { left, right }; 10 | 11 | class MemberDecl { 12 | public: 13 | int var = 0, type = 1; // you can now init here for members 14 | char c = 'C'; 15 | MemberDecl() = default; 16 | Direction dir = Direction::left; 17 | 18 | void Func() { 19 | std::cout << var << " : " << type << " " << c << "\n"; 20 | } 21 | }; 22 | 23 | 24 | int main(int argc, char **argv) { 25 | MemberDecl m; 26 | m.Func(); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /member_fun_pointer/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: memb-test 4 | 5 | memb-test: main.cpp 6 | $(CXX) $(CXX_FLAGS) main.cpp -o memb-test 7 | # $(CXX) $(CXX_FLAGS) func.cpp -o func-test 8 | clean: 9 | rm -f memb-test func-test 10 | -------------------------------------------------------------------------------- /member_fun_pointer/main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | How to create a Pointer to member function of a class 4 | -Jared Bruni 5 | 6 | */ 7 | 8 | 9 | #include 10 | #include 11 | 12 | 13 | class Point { 14 | public: 15 | Point() = default; 16 | Point(const int &xx, const int &yy) : x(xx), y(yy) { 17 | 18 | } 19 | void setXY(const int &xx, const int &yy) { 20 | x = xx; 21 | y = yy; 22 | } 23 | int getX() const { return x; } 24 | int getY() const { return y; } 25 | 26 | int addTogether() { return x+y; } 27 | int mulTogether() { return x*y; } 28 | 29 | protected: 30 | int x,y; 31 | 32 | 33 | }; 34 | 35 | int main() { 36 | // pointer to member function 37 | int (Point::*mem_ptr)() = &Point::addTogether; 38 | 39 | Point p(100,100); 40 | 41 | // use pointer to class/member function 42 | int value = (p.*mem_ptr)(); 43 | 44 | std::cout << "Value:" << value << "\n"; 45 | 46 | mem_ptr = &Point::mulTogether; 47 | 48 | value = (p.*mem_ptr)(); 49 | 50 | std::cout << "Value: " << value << "\n"; 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /memfile/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 -Wall 2 | 3 | all: memfile-test 4 | 5 | memfile-test: main.cpp 6 | $(CXX) $(CXX_FLAGS) main.cpp -o memfile-test 7 | 8 | clean: 9 | rm -f memfile-test 10 | 11 | -------------------------------------------------------------------------------- /memfile/main.cpp: -------------------------------------------------------------------------------- 1 | #include"memfile.hpp" 2 | #include 3 | #include"memfile_hpp.hpp" 4 | 5 | 6 | int main(int argc, char **argv) { 7 | mem::MemFile file, bfile; 8 | // open from exisiting file 9 | if(!file.open("./main.cpp")) { 10 | std::cerr << "Could not open file: \n"; 11 | exit(EXIT_FAILURE); 12 | } 13 | // loop read each byte 14 | while(!file.eof()) { 15 | char b; 16 | file.read(&b, 1); 17 | std::cout << b; 18 | } 19 | // close file 20 | file.close(); 21 | // open memory 22 | if(!bfile.open(memfile_hpp_bytes, memfile_hpp_length)) { 23 | std::cerr << "Could not open byte stream..\n"; 24 | exit(EXIT_FAILURE); 25 | } 26 | // replace first character with an @ 27 | char c = '@'; 28 | bfile.write(&c, 1); 29 | // rewind to begining 30 | bfile.rewind(); 31 | // loop and read each character 32 | while(!bfile.eof()) { 33 | char b; 34 | bfile.read(&b, 1); 35 | std::cout << b; 36 | } 37 | // close memory file 38 | bfile.close(); 39 | return EXIT_SUCCESS; 40 | } 41 | -------------------------------------------------------------------------------- /misc/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS= -std=c++11 3 | 4 | all: forward-test 5 | 6 | forward-test: forward.cpp 7 | $(CXX) $(CXX_FLAGS) forward.cpp -o forward-test 8 | clean: 9 | rm -f forward-test 10 | -------------------------------------------------------------------------------- /misc/forward.cpp: -------------------------------------------------------------------------------- 1 | // from page 207 from Effective Modern C++ 2 | 3 | #include 4 | #include 5 | 6 | // function to be called from fwd template 7 | void passed(const std::vector &v) { 8 | for(auto &i : v) { 9 | std::cout << i << ","; 10 | } 11 | std::cout << "\n"; 12 | } 13 | 14 | 15 | 16 | // passes parameters to passed 17 | template 18 | void fwd(Ts&&... params) { 19 | passed(std::forward(params)...); 20 | } 21 | 22 | 23 | int main(int argc, char **argv) { 24 | std::vector values = {4,5,6}; 25 | auto init_list = {1, 2, 3}; 26 | fwd(init_list); // initalizer list 27 | fwd(values); // pass vector 28 | return 0; 29 | } -------------------------------------------------------------------------------- /move/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -O2 -Wall -std=c++11 3 | 4 | all: movet move-test2 move-test3 5 | 6 | movet: move_test.cc 7 | $(CXX) move_test.cc -o movet $(FLAGS) 8 | move-test2: move_test2.cc 9 | $(CXX) move_test2.cc -o move-test2 $(FLAGS) 10 | move-test3: move_test3.cc 11 | $(CXX) move_test3.cc -o move-test3 $(FLAGS) 12 | clean: 13 | rm -f movet move-test2 move-test3 14 | -------------------------------------------------------------------------------- /move/move_test.cc: -------------------------------------------------------------------------------- 1 | /* move test 2 | written by Jared Bruni 3 | 4 | http://lostsidedead.com 5 | 6 | */ 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | 14 | class MoveVector { 15 | public: 16 | explicit MoveVector(std::vector &&v) : vec{v} { 17 | std::cout << "Moved vector\n"; 18 | } 19 | void print() { 20 | for(auto i : vec) { 21 | std::cout << i << " "; 22 | } 23 | std::cout << "\n"; 24 | } 25 | 26 | private: 27 | std::vector vec; 28 | 29 | }; 30 | 31 | int main(int argc, char **argv) { 32 | 33 | std::vector vz; 34 | std::cout << "Filling vector..\n"; 35 | for(unsigned int i = 0; i < 10000; ++i) { 36 | std::ostringstream stream; 37 | stream << i; 38 | vz.push_back(stream.str()); 39 | } 40 | // instead of copying use move 41 | MoveVector v(std::move(vz)); 42 | v.print(); 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /mutable/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXXFLAGS= -Wall -std=c++11 3 | 4 | all: mut-test 5 | 6 | mut-test: mut.cc 7 | $(CXX) mut.cc -o mut-test $(CXXFLAGS) 8 | clean: 9 | rm -rf mut-test 10 | -------------------------------------------------------------------------------- /namespace/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS=-Wall -std=c++11 2 | 3 | all: namespace-test namespace-test2 namespace-test3 4 | 5 | namespace-test: inline_namespace_ex.cc 6 | $(CXX) inline_namespace_ex.cc -o namespace-test $(FLAGS) 7 | namespace-test2: namespace2.cpp 8 | $(CXX) namespace2.cpp -o namespace-test2 $(FLAGS) 9 | namespace-test3: namespace3.cpp 10 | $(CXX) namespace3.cpp -o namespace-test3 $(FLAGS) 11 | clean: 12 | rm -rf namespace-test namespace-test2 namespace-test3 13 | -------------------------------------------------------------------------------- /namespace/namespace2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | namespace space1 { 6 | // define in namespace 7 | void printString(std::string text) { 8 | std::cout << "Space 1: " << text << "\n"; 9 | } 10 | } 11 | 12 | namespace space2 { 13 | // define decl only 14 | void printString(std::string text); 15 | } 16 | 17 | // implemented 18 | void space2::printString(std::string text) { 19 | std::cout << "Space 2: " << text << "\n"; 20 | } 21 | 22 | void fromHere() { 23 | using namespace space2; 24 | 25 | printString("Hello from here."); 26 | } 27 | 28 | 29 | int main(int argc, char **argv) { 30 | 31 | space1::printString("Hello World #1"); 32 | space2::printString("Hello World #2"); 33 | using namespace space1; 34 | 35 | printString("Hey "); 36 | fromHere(); 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /namespace/namespace3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | namespace space1 { 5 | class Jared { 6 | public: 7 | void say(std::string text) { 8 | std::cout << "Jared: " << text << "\n"; 9 | } 10 | }; 11 | } 12 | 13 | namespace space2 { 14 | class Jared { 15 | public: 16 | void say(std::string text); 17 | }; 18 | 19 | void Jared::say(std::string text) { 20 | std::cout << "Jared from space2: " << text << "\n"; 21 | } 22 | } 23 | 24 | template 25 | void SayHello(T &t) { 26 | t.say(" Hello World"); 27 | } 28 | 29 | int main(int argc, char **argv) { 30 | space1::Jared jared1; 31 | space2::Jared jared2; 32 | SayHello(jared1); 33 | SayHello(jared2); 34 | return 0; 35 | 36 | } -------------------------------------------------------------------------------- /operator/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS= -std=c++11 -Wall 2 | all: operator-test delete-test plus-test equal-test 3 | 4 | operator-test: 5 | $(CXX) -Wall operator.cc -o operator-test -std=c++11 6 | delete-test: default.cc 7 | $(CXX) -Wall default.cc -o delete-test -std=c++11 8 | plus-test: plus.cc 9 | $(CXX) -Wall plus.cc -o plus-test -std=c++11 10 | equal-test: equal.cpp 11 | $(CXX) $(FLAGS) equal.cpp -o equal-test 12 | clean: 13 | rm -f operator-test delete-test plus-test equal-test 14 | -------------------------------------------------------------------------------- /operator/equal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | class Complex { 5 | public: 6 | Complex() : t1{}, t2{} { } 7 | Complex(T tt1, T tt2) : t1{tt1}, t2{tt2} { } 8 | Complex(const Complex &c) : t1{c.t1}, t2{c.t2} { 9 | } 10 | Complex &operator=(const Complex &c) { 11 | t1 = c.t1; 12 | t2 = c.t2; 13 | return *this; 14 | } 15 | 16 | Complex operator+(const Complex &c) { 17 | Complex t(*this); 18 | t.t1 += c.t1; 19 | t.t2 += c.t2; 20 | return t; 21 | } 22 | 23 | T one() const { return t1; } 24 | T two() const { return t2; } 25 | 26 | private: 27 | T t1, t2; 28 | }; 29 | 30 | template 31 | std::ostream &operator<<(std::ostream &out, const Complex &c) { 32 | out << "<" << c.one() << ":" << c.two() << ">"; 33 | return out; 34 | } 35 | 36 | int main() { 37 | 38 | Complex f(100.0f, 100.0f), f2(100.0f, 104.0f); 39 | 40 | f = f + f2; 41 | std::cout << f << "\n"; 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /operator/operator.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class ObjectType { 5 | std::string text; 6 | public: 7 | ObjectType() = default; 8 | // disallow copying 9 | ObjectType(const ObjectType &t) = delete; 10 | void operator=(const ObjectType &t) = delete; 11 | void operator=(std::string text); 12 | // print text 13 | void say(std::string text); 14 | }; 15 | 16 | void ObjectType::say(std::string text) { 17 | std::cout << text << "\n"; 18 | this->text = text; 19 | } 20 | 21 | void ObjectType::operator=(std::string text) { 22 | this->text = text; 23 | } 24 | 25 | 26 | template 27 | auto Proc(Type1 type1, Type2 type2) -> decltype(type1*type2) { 28 | return (type1*type2); 29 | } 30 | 31 | 32 | int main(int argc, char **argv) { 33 | 34 | 35 | ObjectType otype, ctype; 36 | 37 | otype.say("Hello World\n"); 38 | 39 | // copying not allowed 40 | // otype = ctype; 41 | 42 | // ok 43 | otype = "test"; 44 | 45 | int value = Proc(10, 10); 46 | std::cout << " value = " << value << "\n"; 47 | double dvalue = Proc(10.5, 10.5); 48 | std::cout << " double value = " << dvalue << "\n"; 49 | 50 | 51 | return 0; 52 | } -------------------------------------------------------------------------------- /operator_new/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: new-test 4 | 5 | new-test: new.cpp 6 | $(CXX) $(CXX_FLAGS) new.cpp -o new-test 7 | clean: 8 | rm -f new-test 9 | -------------------------------------------------------------------------------- /operator_new/new.cpp: -------------------------------------------------------------------------------- 1 | /* overloaded opreator new */ 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | int call_new = 0; 8 | 9 | void *operator new(std::size_t size) { 10 | std::cout << "Allocated: " << size << " at " << "test" << "\n"; 11 | ++call_new; 12 | return std::malloc(size); 13 | } 14 | 15 | void operator delete(void *p) noexcept { 16 | std::cout << "Deleted\n"; 17 | std::free(p); 18 | --call_new; 19 | } 20 | 21 | void checkIfEqual() { 22 | if(call_new == 0) { 23 | std::cout << "All new matched with delete..\n"; 24 | } else { 25 | std::cout << "New not matched with delete " << call_new << " Times...\n"; 26 | } 27 | } 28 | 29 | int main(int argc, char **argv) { 30 | 31 | 32 | int *x = new int; 33 | delete x; 34 | 35 | std::string *s = new std::string(); 36 | 37 | checkIfEqual(); 38 | 39 | int *values[8]; 40 | for(unsigned int v = 0; v < 8; ++v) values[v] = new int; 41 | 42 | for(unsigned int v = 0; v < 8; ++v) delete values[v]; 43 | 44 | checkIfEqual(); 45 | return 0; 46 | } -------------------------------------------------------------------------------- /override/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -Wall -std=c++11 3 | 4 | all: override-test virtual-test 5 | 6 | override-test: override_test.cc 7 | $(CXX) override_test.cc -o override-test $(FLAGS) 8 | virtual-test: virtual_base.cc 9 | $(CXX) virtual_base.cc -o virtual-test $(FLAGS) 10 | clean: 11 | rm -f override-test virtual-test 12 | -------------------------------------------------------------------------------- /override/ptr/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS= -std=c++11 3 | 4 | all: testcode 5 | 6 | testcode: main.cpp 7 | $(CXX) $(CXX_FLAGS) main.cpp -o testcode 8 | clean: 9 | rm -f testcode 10 | -------------------------------------------------------------------------------- /override/ptr/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | class X { 5 | public: 6 | int x,y,z; 7 | virtual void f() { 8 | std::cout << "X here\n"; 9 | } 10 | }; 11 | 12 | class XX : public X { 13 | public: 14 | virtual void f() override { 15 | std::cout << "XX here\n"; 16 | } 17 | }; 18 | 19 | int main(int argc, char **argV) { 20 | 21 | std::unique_ptr x(new X()); 22 | std::unique_ptr xx(new XX()); // pass XX to X* 23 | 24 | x->f(); 25 | xx->f(); 26 | 27 | 28 | return 0; 29 | 30 | } -------------------------------------------------------------------------------- /persist/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS=-std=c++11 2 | all: persist-test persist-vec-test 3 | 4 | persist-test: persist.cc 5 | $(CXX) $(CFLAGS) -Wall persist.cc -o persist-test 6 | persist-vec-test: persist-vector-main.cpp 7 | $(CXX) $(CFLAGS) persist-vector-main.cpp -o persist-vec-test 8 | clean: 9 | rm -f persist-test persist-vec-test 10 | -------------------------------------------------------------------------------- /persist/ioadd.hpp: -------------------------------------------------------------------------------- 1 | #ifndef IOMAX_H_ 2 | #define IOMAX_H_ 3 | 4 | #include 5 | #include 6 | 7 | // read integer from stream 8 | int getInteger(std::istream &istr) { 9 | std::string val; 10 | std::getline(istr, val); 11 | return atoi(val.c_str()); 12 | } 13 | // read string (line) from stream 14 | std::string getString(std::istream &istr) { 15 | std::string val; 16 | std::getline(istr, val); 17 | return val; 18 | } 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /pool/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXXFLAGS= -std=c++11 3 | 4 | all: pool-test 5 | 6 | pool-test: driver.cc 7 | $(CXX) driver.cc -o pool-test $(CXXFLAGS) 8 | clean: 9 | rm -f pool-test 10 | -------------------------------------------------------------------------------- /pool/driver.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include"memory.hpp" 5 | 6 | int main(int argc, char **argv) { 7 | pool::Alloc a; // scoped memory pool 8 | std::cout << "Allocating to Pool....\n"; 9 | for(unsigned int i = 0; i < 100; ++i) { 10 | unsigned int *buffer = (unsigned int*)a.alloc(sizeof(unsigned int)); 11 | *buffer = rand()%0xFFFFFFFF; 12 | std::cout << " Allocated Address: 0x" << std::hex << (unsigned long)buffer << " value = " << std::dec << *buffer << "\n"; 13 | } 14 | return 0; 15 | 16 | } -------------------------------------------------------------------------------- /printdir/Makefile: -------------------------------------------------------------------------------- 1 | PRINTDIR_SOURCE=printdir.cpp 2 | PRINTDIR_OUTPUT=printdir-test 3 | CFLAGS=-std=c++11 4 | 5 | all: $(PRINTDIR_OUTPUT) 6 | 7 | $(PRINTDIR_OUTPUT): $(PRINTDIR_SOURCE) 8 | $(CXX) $(CFLAGS) $(PRINTDIR_SOURCE) -o $(PRINTDIR_OUTPUT) 9 | clean: 10 | rm -f printdir-test 11 | -------------------------------------------------------------------------------- /random/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS=-Wall -std=c++11 3 | all: randtest 4 | 5 | randtest: r.cc 6 | $(CXX) r.cc -o randtest $(FLAGS) 7 | # $(CXX) shuffle.cc -o randtest2 $(FLAGS) 8 | # $(CXX) shuffle2.cc -o randtest3 $(FLAGS) 9 | clean: 10 | rm -f *.o randtest randtest2 randtest3 11 | -------------------------------------------------------------------------------- /random/r.cc: -------------------------------------------------------------------------------- 1 | // example of new random in C++11 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | int main(int argc, char **argv) { 8 | 9 | unsigned int i = 0; 10 | std::default_random_engine dre(static_cast(std::time(0))); 11 | 12 | for(i = 0; i < 10; ++i) { 13 | std::cout << "Random number 0-10: " << dre()%10 << "\n"; 14 | } 15 | 16 | std::uniform_int_distribution ui(0, 10); 17 | for(i = 0; i < 10; ++i) { 18 | std::cout << "Uniform: " << ui(dre) << "\n"; 19 | } 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /random/randtest: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/random/randtest -------------------------------------------------------------------------------- /random/shuffle.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void printVector(std::vector &v) { 7 | std::cout << "[ "; 8 | for(auto &i : v) { 9 | 10 | std::cout << i << " "; 11 | } 12 | std::cout << " ]\n"; 13 | } 14 | 15 | int main(int argc, char **argv) { 16 | 17 | std::default_random_engine dre(static_cast(std::time(0))); 18 | unsigned int i = 0; 19 | std::vector values; 20 | 21 | 22 | for(i = 0; i < 25; ++i) 23 | values.push_back(dre()%25); 24 | 25 | std::cout << "Value before shuffle: \n"; 26 | printVector(values); 27 | std::cout << "Value after shuffle:\n "; 28 | std::shuffle(values.begin(), values.end(), dre); 29 | printVector(values); 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /rar_extract/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 -O2 2 | SOURCE_FILES=unrar_extract.cpp 3 | all: unrar_extract 4 | 5 | unrar_extract: $(SOURCE_FILES) 6 | $(CXX) $(CXX_FLAGS) $(SOURCE_FILES) -o unrar_extract 7 | clean: 8 | rm -f unrar_extract 9 | install: 10 | cp unrar_extract /usr/bin/unrar_extract 11 | -------------------------------------------------------------------------------- /rar_extract/unrar_extract: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/rar_extract/unrar_extract -------------------------------------------------------------------------------- /rar_extract/unrar_extract.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/rar_extract/unrar_extract.exe -------------------------------------------------------------------------------- /readfast_textscroll/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS= -std=c++11 2 | 3 | all: textscroll plaintext_scroll linescroll 4 | 5 | textscroll: scroll.cpp 6 | $(CXX) $(CFLAGS) scroll.cpp -o textscroll 7 | plaintext_scroll: textscroll.cpp 8 | $(CXX) $(CFLAGS) textscroll.cpp -o plaintext_scroll 9 | linescroll: linescroll.cpp 10 | $(CXX) $(CFLAGS) linescroll.cpp -o linescroll 11 | clean: 12 | rm -f textscroll plaintext_scroll linescroll 13 | -------------------------------------------------------------------------------- /readfast_textscroll/linescroll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/readfast_textscroll/linescroll -------------------------------------------------------------------------------- /readfast_textscroll/plaintext_scroll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/readfast_textscroll/plaintext_scroll -------------------------------------------------------------------------------- /readfast_textscroll/scroll.cpp: -------------------------------------------------------------------------------- 1 | #include"lexer.hpp" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | 9 | int main(int argc, char **argv) { 10 | 11 | if(argc == 3) { 12 | 13 | std::fstream source; 14 | source.open(argv[1], std::ios::in); 15 | 16 | if(!source.is_open()) { 17 | std::cerr << "Error could not open file: " << argv[1] << "\n"; 18 | exit(0); 19 | } 20 | 21 | lex::Scanner scan(source); 22 | lex::Token token; 23 | unsigned int t_count = 0; 24 | unsigned int mill = atoi(argv[2]); 25 | 26 | while(scan.valid()) { 27 | scan >> token; 28 | std::cout << token.getToken() << "\n"; 29 | ++t_count; 30 | std::this_thread::sleep_for(std::chrono::milliseconds(mill)); 31 | 32 | } 33 | source.close(); 34 | std::cout << "Printed: " << t_count << " Tokens \n"; 35 | } 36 | else { 37 | std::cerr << "Error program requires arguments..\ntextscroll sourcefile duration\n"; 38 | } 39 | 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /readfast_textscroll/textscroll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/readfast_textscroll/textscroll -------------------------------------------------------------------------------- /regex/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS=-Wall -std=c++11 2 | 3 | all: regex-test regex-test2 4 | 5 | regex-test: regex_test.cc 6 | $(CXX) regex_test.cc -o regex-test $(FLAGS) 7 | regex-test2: regex.cpp 8 | $(CXX) $(FLAGS) regex.cpp -o regex-test2 9 | 10 | clean: 11 | rm -rf regex-test regex-test2 12 | 13 | -------------------------------------------------------------------------------- /regex/regex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int main(int argc, char **argv) { 7 | 8 | std::cout << "Enter IP Address: "; 9 | std::string ip; 10 | std::getline(std::cin, ip); 11 | 12 | if(ip.length() == 0) { 13 | std::cerr << "Error nothing entered\n"; 14 | exit(EXIT_FAILURE); 15 | } 16 | 17 | std::regex r("(\\d{1,3}(\\.\\d{1,3}){3})"); 18 | bool is_valid = std::regex_match(ip, r); 19 | if(is_valid) 20 | std::cout << ip << " is a valid IP address\n"; 21 | else 22 | std::cout << ip << " is not a valid IP address\n"; 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /rename_files/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS= -Wall -O3 -std=c++11 2 | 3 | all: rename-file 4 | 5 | rename-file: file_rename.cc 6 | $(CXX) $(FLAGS) file_rename.cc -o rename-file 7 | clean: 8 | rm -f rename-file 9 | 10 | 11 | -------------------------------------------------------------------------------- /replace/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: replace-test 4 | 5 | replace-test: main.cpp 6 | $(CXX) main.cpp -o replace-test $(CXX_FLAGS) 7 | clean: 8 | rm -f replace-test 9 | -------------------------------------------------------------------------------- /replace/replace.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __REPLACE_H__ 2 | #define __REPLACE_H__ 3 | 4 | #include 5 | #include 6 | 7 | class NotFound {}; 8 | 9 | 10 | std::string replaceString(const std::string &text, const std::string &rep_source, const std::string &rep_what) { 11 | std::string temp = text; 12 | int pos = temp.find(rep_source); 13 | if(pos == -1) throw NotFound(); 14 | while( pos != -1 ) { 15 | std::string left_value=temp.substr(0, pos); 16 | std::string right_value = temp.substr(pos + rep_source.length(),temp.length()); 17 | temp = left_value+rep_what+right_value; 18 | pos = temp.find(rep_source); 19 | } 20 | return temp; 21 | } 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /rotate/Makefile: -------------------------------------------------------------------------------- 1 | SOURCE=ror_rol.cpp 2 | FLAGS=-std=c++11 3 | 4 | ror-test: ror_rol.cpp 5 | $(CXX) $(FLAGS) ror_rol.cpp -o ror-test 6 | clean: 7 | rm -f ror-test 8 | -------------------------------------------------------------------------------- /rotate/ror_rol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | T ror(T x, unsigned int m) 6 | { 7 | return (x >> m) | (x << sizeof(T)*8 - m); 8 | } 9 | template 10 | T rol(T x, unsigned int m) { 11 | return (x << m) | (x >> (sizeof(T)*8 -m)); 12 | } 13 | 14 | int main(int argc, char **argv) { 15 | std::cout << "Enter 8-bit value: "; 16 | unsigned int v; 17 | std::cin >> v; 18 | if(v > 255) { 19 | std::cerr << "Should be an 8 bit value (0-255)\n"; 20 | exit(1); 21 | } 22 | unsigned char value = static_cast(v); 23 | std::cout << "Rotate by:"; 24 | unsigned int r; 25 | std::cin >> r; 26 | if(r < 1 || r > 7) { 27 | std::cerr << "Should be 1-7\n"; 28 | exit(1); 29 | } 30 | std::bitset<8> before(value); 31 | std::cout << "Before: " << v << " = " << before << "\n"; 32 | unsigned char left, right; 33 | left = rol(value, r); 34 | right = ror(value, r); 35 | std::bitset<8> after_ror(right), after_rol(left); 36 | std::cout << "ROR: " << static_cast(right) << " = " << after_ror << "\n"; 37 | std::cout << "ROL: " << static_cast(left) << " = " << after_rol << "\n"; 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /rvalue/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS=-std=c++11 3 | 4 | all: rvalue1-test rvalue2-test rvalue3-test rvalue4-test rvalue5-test 5 | 6 | rvalue1-test: rvalue1.cpp 7 | $(CXX) $(CXX_FLAGS) rvalue1.cpp -o rvalue1-test 8 | rvalue2-test: rvalue2.cpp 9 | $(CXX) $(CXX_FLAGS) rvalue2.cpp -o rvalue2-test 10 | rvalue3-test: rvalue3.cpp 11 | $(CXX) $(CXX_FLAGS) rvalue3.cpp -o rvalue3-test 12 | rvalue4-test: rvalue4.cpp 13 | $(CXX) $(CXX_FLAGS) rvalue4.cpp -o rvalue4-test 14 | rvalue5-test: rvalue5.cpp 15 | $(CXX) $(CXX_FLAGS) rvalue5.cpp -o rvalue5-test 16 | clean: 17 | rm -f rvalue1-test rvalue2-test rvalue3-test rvalue4-test rvalue5-test 18 | -------------------------------------------------------------------------------- /sdl2_test/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | SDL_PATH=/opt/local/sdl 3 | 4 | FLAGS=-std=c++11 `$(SDL_PATH)/bin/sdl2-config --cflags --libs` -framework OpenGL 5 | all: 6 | $(CXX) SDL2_test.cpp -o sdl2-test $(FLAGS) 7 | $(CXX) SDL2_test2.cpp -o sdl2-test2 $(FLAGS) 8 | $(CXX) pong.cpp -o pong-test $(FLAGS) 9 | clean: 10 | rm -f sdl2-test sdl2-test2 pong-test 11 | -------------------------------------------------------------------------------- /sdl2_test/ball.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/sdl2_test/ball.bmp -------------------------------------------------------------------------------- /sdl2_test/paddle.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/sdl2_test/paddle.bmp -------------------------------------------------------------------------------- /set/Makefile: -------------------------------------------------------------------------------- 1 | 2 | FLAGS= -std=c++11 3 | 4 | all: set-test 5 | 6 | set-test: set.cpp 7 | $(CXX) $(FLAGS) set.cpp -o set-test 8 | clean: 9 | rm -f set-test 10 | -------------------------------------------------------------------------------- /set/set-test: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/set/set-test -------------------------------------------------------------------------------- /shared/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXXFLAGS=-Wall -std=c++11 3 | 4 | all: sharedtest sharedtest2 5 | 6 | sharedtest: sharedtest.cpp 7 | $(CXX) sharedtest.cpp -o sharedtest $(CXXFLAGS) 8 | sharedtest2: sharedtest2.cpp 9 | $(CXX) sharedtest2.cpp -o sharedtest2 $(CXXFLAGS) 10 | clean: 11 | rm -f sharedtest sharedtest2 12 | -------------------------------------------------------------------------------- /shared/sharedtest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | // simple class to illustrate point 7 | class Item { 8 | public: 9 | Item(std::string text) : temp_text(text) { 10 | } 11 | ~Item() { 12 | std::cout << "Released: " << temp_text << "\n"; 13 | } 14 | void lowerCase() { 15 | for(int i = 0; i < temp_text.length(); ++i) 16 | temp_text[i] = tolower(temp_text[i]); 17 | } 18 | std::string data() { return temp_text; } 19 | private: 20 | std::string temp_text; 21 | }; 22 | 23 | // uses shared_ptr 24 | bool checkIfQuit(std::shared_ptr &item) { 25 | if(item->data() == "quit") return true; 26 | return false; 27 | } 28 | 29 | 30 | int main(int argc, char **argv) { 31 | // will autorelease Item on destructor using shared_ptr 32 | std::vector> items; 33 | while(1) { 34 | std::string s; 35 | std::cout << "Enter string quit to exit loop: "; 36 | std::getline(std::cin, s); 37 | items.push_back(std::shared_ptr(new Item(s))); 38 | items[items.size()-1]->lowerCase(); 39 | if(checkIfQuit(items[items.size()-1]) == true) break; 40 | } 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /smart_pointer/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | all: unique-test smart-test 3 | 4 | unique-test: unique.cc 5 | $(CXX) $(CXX_FLAGS) -Wall unique.cc -o unique-test 6 | smart-test: smart.cpp 7 | $(CXX) $(CXX_FLAGS) smart.cpp -o smart-test 8 | clean: 9 | rm -f unique-test smart-test 10 | -------------------------------------------------------------------------------- /sort/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS=-std=c++11 -Wall 3 | 4 | all: sort1-test sort2-test 5 | 6 | sort1-test: sort1.cpp 7 | $(CXX) sort1.cpp -o sort1-test $(CXX_FLAGS) 8 | sort2-test: sort2.cpp 9 | $(CXX) sort2.cpp -o sort2-test $(CXX_FLAGS) 10 | clean: 11 | rm -f sort1-test sort2-test 12 | -------------------------------------------------------------------------------- /sort/sort1.cpp: -------------------------------------------------------------------------------- 1 | /* sort example 2 | written by Jared Bruni 3 | http://lostsidedead.com 4 | 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main(int argc, char **argv) { 13 | 14 | std::vector strings; 15 | 16 | for(;;) { 17 | std::cout << "Enter string (quit to exit and sort):"; 18 | std::string s; 19 | std::getline(std::cin,s); 20 | if(s=="quit") break; 21 | strings.push_back(s); 22 | } 23 | 24 | std::sort(strings.begin(), strings.end()); 25 | 26 | std::cout << "Sorted..\n"; 27 | 28 | for(auto &i : strings) { 29 | std::cout << i << "\n"; 30 | } 31 | 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /sort_files/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS=-std=c++11 2 | 3 | all: sort-files 4 | 5 | sort-files: main.cpp 6 | $(CXX) main.cpp -o sort-files $(CXX_FLAGS) 7 | clean: 8 | rm -f sort-files 9 | 10 | -------------------------------------------------------------------------------- /sort_files/main.cpp: -------------------------------------------------------------------------------- 1 | #include"sfile.hpp" 2 | 3 | 4 | int main(int argc, char **argv) { 5 | FileSort file_sort; 6 | for(unsigned int i = 1; i < argc; ++i) { 7 | file_sort.addFile(argv[i]); 8 | } 9 | 10 | file_sort.sortAndOutput("sorted_text.txt"); 11 | return 0; 12 | } -------------------------------------------------------------------------------- /static/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: static1-test static2-test 4 | 5 | static1-test: static1.cpp 6 | $(CXX) $(CXX_FLAGS) static1.cpp -o static1-test 7 | static2-test: static2.cpp 8 | $(CXX) $(CXX_FLAGS) static2.cpp -o static2-test 9 | clean: 10 | rm -f static1-test static2-test 11 | -------------------------------------------------------------------------------- /static/static1.cpp: -------------------------------------------------------------------------------- 1 | #include "static_main.h" 2 | 3 | #include 4 | 5 | 6 | class TestProgram { 7 | 8 | public: 9 | static int main(int argc, char **argv) { 10 | TestProgram program; 11 | program.print("Hello World\n"); 12 | return 0; 13 | } 14 | private: 15 | void print(std::string s) { 16 | std::cout << s; 17 | } 18 | }; 19 | 20 | STATIC_MAIN(TestProgram) 21 | -------------------------------------------------------------------------------- /static/static2.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include"static_main.h" 3 | #include 4 | 5 | 6 | // using a static member variable 7 | 8 | class UserType { 9 | public: 10 | UserType() { 11 | counter++; 12 | } 13 | static int counter; 14 | }; 15 | 16 | int UserType::counter = 0; 17 | 18 | 19 | // static main program style similar to Java 20 | 21 | class Program { 22 | public: 23 | static int main(int argc, char **argv) { 24 | 25 | for(int i = 0; i < 10; ++i) { 26 | UserType type; 27 | } 28 | 29 | std::cout << UserType::counter << " number created..\n"; 30 | return 0; 31 | } 32 | }; 33 | 34 | 35 | STATIC_MAIN(Program) -------------------------------------------------------------------------------- /static/static_main.h: -------------------------------------------------------------------------------- 1 | #ifndef __STATIC_MAIN_H__ 2 | #define __STATIC_MAIN_H__ 3 | 4 | 5 | #define STATIC_MAIN(X) int main(int argc, char **argv) { return X::main(argc, argv); } 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /stopwatch/Makefile: -------------------------------------------------------------------------------- 1 | MAIN_SOURCE=main.cpp 2 | STRING_TEST=string-test.cpp 3 | MOVE_TEST=movetest.cpp 4 | LOOP_TEST=looptest.cpp 5 | READ_TEST=readtest.cpp 6 | CXXFLAGS= -std=c++11 7 | 8 | all: stopwatch-test stopwatch-string stopwatch-move loop-test read-test 9 | 10 | stopwatch-test: $(MAIN_SOURCE) 11 | $(CXX) $(CXXFLAGS) $(MAIN_SOURCE) -o stopwatch-test 12 | stopwatch-string: $(STRING_TEST) 13 | $(CXX) $(CXXFLAGS) $(STRING_TEST) -o stopwatch-string 14 | stopwatch-move: $(MOVE_TEST) 15 | $(CXX) $(CXXFLAGS) $(MOVE_TEST) -o stopwatch-move 16 | loop-test: $(LOOP_TEST) 17 | $(CXX) $(CXXFLAGS) $(LOOP_TEST) -o loop-test 18 | read-test: $(READ_TEST) 19 | $(CXX) $(CXXFLAGS) $(READ_TEST) -o read-test 20 | 21 | clean: 22 | rm -f stopwatch-test stopwatch-string stopwatch-move loop-test read-test 23 | -------------------------------------------------------------------------------- /stopwatch/looptest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include"stopwatch.hpp" 6 | 7 | const int arr_size = 9000; 8 | 9 | int array[arr_size][arr_size]; 10 | 11 | void XFirst() { 12 | StopWatch timer("Loop X First"); 13 | for(unsigned int x = 0; x < arr_size; ++x) { 14 | for(unsigned int y = 0; y < arr_size; ++y) { 15 | array[x][y] = rand()%255; 16 | } 17 | } 18 | 19 | 20 | } 21 | 22 | void YFirst() { 23 | StopWatch timer("Loop Y First"); 24 | for(unsigned int y = 0; y < arr_size; ++y) { 25 | for(unsigned int x = 0; x < arr_size; ++x) { 26 | array[x][y] = rand()%255; 27 | } 28 | } 29 | } 30 | 31 | int main() { 32 | 33 | srand(static_cast(time(0))); 34 | XFirst(); 35 | YFirst(); 36 | return 0; 37 | } -------------------------------------------------------------------------------- /stopwatch/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include"stopwatch.hpp" 4 | 5 | 6 | int main() { 7 | 8 | StopWatch value_wait("Outter Loop"); 9 | for(unsigned int i = 0; i < 100; ++i) { 10 | for(unsigned int i = 0; i < 100; ++i) { 11 | StopWatch inner_loop("Inner Loop"); 12 | for(unsigned z = 0; z < 10000; ++z) { } 13 | } 14 | } 15 | 16 | return 0; 17 | } -------------------------------------------------------------------------------- /stopwatch/movetest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include"stopwatch.hpp" 8 | 9 | 10 | 11 | void concat_Values(std::vector &v) { 12 | unsigned long value = 0; 13 | for(auto &i : v) { 14 | value += i; 15 | } 16 | std::cout << "Value is: " << value << "\n"; 17 | } 18 | 19 | 20 | void copy_Test(std::vector &v) { 21 | StopWatch clock("copy"); 22 | std::vector mv(v); // temporary to test operation 23 | concat_Values(mv); 24 | } 25 | 26 | 27 | std::vector mv; 28 | 29 | void move_Test(std::vector &&v) { 30 | StopWatch clock("move"); 31 | mv = v; 32 | concat_Values(mv); 33 | } 34 | 35 | 36 | int main() { 37 | 38 | std::cout << "Please wait ....\n"; 39 | std::srand(static_cast(std::time(0))); 40 | 41 | std::vector test_vector; 42 | for(unsigned long i = 0; i < rand()%255+99999999; ++i) test_vector.push_back(rand()%255); 43 | 44 | copy_Test(test_vector); 45 | move_Test(std::move(test_vector)); 46 | std::cout << "Container has: " << mv.size() << " elements\n"; 47 | 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /stream_insert_iterators/Makefile: -------------------------------------------------------------------------------- 1 | CXX_FLAGS= -std=c++11 2 | 3 | all: insert_iterator_test stream_iterator_test 4 | insert_iterator_test: insert_iterator.cpp 5 | $(CXX) $(CXX_FLAGS) insert_iterator.cpp -o insert_iterator_test 6 | stream_iterator_test: stream_iterator.cpp 7 | $(CXX) $(CXX_FLAGS) stream_iterator.cpp -o stream_iterator_test 8 | clean: 9 | rm -f insert_iterator_test stream_Iterator_test 10 | 11 | -------------------------------------------------------------------------------- /stream_insert_iterators/insert_iterator.cpp: -------------------------------------------------------------------------------- 1 | 2 | // Insert Iterators demo 3 | // Will insert with back_inserter or front_inserter 4 | 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | 15 | template 16 | void Print(std::string data_type, std::ostream &out, T type) { 17 | out << "Inserted into " << data_type << " = { "; 18 | for(auto &i : type) { 19 | out << i << " "; 20 | 21 | } 22 | out << "}\n"; 23 | } 24 | 25 | int main() { 26 | std::list value1 = { 0,10,30,40,50 }; 27 | std::vector value2; 28 | std::copy(value1.begin(), value1.end(), std::back_inserter(value2)); 29 | std::set value3; 30 | std::copy(value1.begin(), value1.end(), std::inserter(value3, value3.begin())); 31 | std::deque value4; 32 | std::copy(value1.begin(), value1.end(), std::front_inserter(value4)); 33 | Print("Vector",std::cout, value2); 34 | Print("Set",std::cout, value3); 35 | Print("Deque",std::cout, value4); 36 | return 0; 37 | } -------------------------------------------------------------------------------- /stream_insert_iterators/stream_iterator.cpp: -------------------------------------------------------------------------------- 1 | /* stream iterator test 2 | 3 | Adapted from The C++ Stanard Library second edition 4 | 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | int main() { 14 | std::vector value1; 15 | std::copy(std::istream_iterator(std::cin), std::istream_iterator(),std::back_inserter(value1)); 16 | 17 | std::sort(value1.begin(), value1.end()); 18 | // Unique 19 | std::cout << "Unique copy\n"; 20 | std::cout << "Unique copy\n"; 21 | std::unique_copy(value1.begin(), value1.end(), std::ostream_iterator(std::cout, "\n")); 22 | // Standard Copy 23 | std::cout << "Standard Copy\n"; 24 | std::copy(value1.begin(), value1.end(), std::ostream_iterator(std::cout, " ")); 25 | std::cout << "\n"; 26 | // Copy Vector of int 27 | std::cout << "Copy Integers\n"; 28 | std::vector v {0,1,3,4,6}; 29 | std::copy(v.begin(), v.end(), std::ostream_iterator(std::cout, " ")); 30 | std::cout << "\n"; 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /stringstream/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS=-std=c++11 -O2 -Wall 2 | 3 | all: ss-test iss-test iss2-test 4 | 5 | ss-test: ss.cc 6 | $(CXX) ss.cc -o ss-test $(FLAGS) 7 | iss-test: iss.cc 8 | $(CXX) iss.cc -o iss-test $(FLAGS) 9 | iss2-test: iss2.cc 10 | $(CXX) iss2.cc -o iss2-test $(FLAGS) 11 | clean: 12 | rm -f ss-test iss-test iss2-test 13 | -------------------------------------------------------------------------------- /stringstream/iss2.cc: -------------------------------------------------------------------------------- 1 | /* C++11 example 2 | istringstream example 3 | 4 | enter a variable name followed by 4 integers 5 | it will add together the integers 6 | */ 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | typedef struct _Values { 13 | std::string name; 14 | int x,y,w,h; 15 | } Values; 16 | 17 | 18 | bool convertText(std::string text, Values &v) { 19 | std::istringstream stream(text); 20 | stream >> v.name >> v.x >> v.y >> v.w >> v.h; 21 | if(stream.fail()) return false; 22 | return true; 23 | } 24 | 25 | int main(int argc, char **argv) { 26 | std::string text; 27 | std::getline(std::cin, text); 28 | Values v; 29 | if(convertText(text, v) == true) { 30 | std::cout << v.name << " values = [" << v.x << "," << v.y << "," << v.w << "," << v.h << "]; \n"; 31 | 32 | int total=v.x+v.y+v.w+v.h; 33 | std::cout << "The total is " << total << "\n"; 34 | } 35 | else { 36 | std::cerr << "Failed to convert \n"; 37 | } 38 | return 0; 39 | } 40 | 41 | -------------------------------------------------------------------------------- /stringstream/ss.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * C++11 Example 4 | * how to use: stringstream 5 | * http://objective-c.info 6 | */ 7 | 8 | 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | 15 | // output to stdout 16 | void out(const std::string &text) { 17 | std::cout << text << "\n"; 18 | } 19 | 20 | 21 | int main(int argc, char **argv) { 22 | int x = 100; 23 | std::string text="hello world\n"; 24 | std::ostringstream stream; 25 | // write to stream 26 | stream << "Value of integer: " << x << "\nValue of string: " << text; 27 | // output as string 28 | out(stream.str()); 29 | stream << " added value\n"; 30 | // convert to string 31 | std::string t = stream.str(); 32 | std::cout << t << "\n"; 33 | 34 | // other way around convert from string to text 35 | std::istringstream input("100 100"); 36 | int y = 0, z = 0; 37 | // scan from string 38 | input >> y >> z; 39 | // add to integers 40 | y += 10; 41 | z += 10; 42 | // output to stdout 43 | std::cout << y << ":" << z << "\n"; 44 | return 0; 45 | } -------------------------------------------------------------------------------- /symbol_table/Makefile: -------------------------------------------------------------------------------- 1 | all: symbol_table-test 2 | 3 | symbol_table-test: symbol_table.cc 4 | $(CXX) -Wall symbol_table.cc -o symbol_table-test -std=c++11 5 | clean: 6 | rm -f symbol_table-test 7 | -------------------------------------------------------------------------------- /templates/template-inst.cpp: -------------------------------------------------------------------------------- 1 | /* Explicit instantiation */ 2 | 3 | #include 4 | #include 5 | 6 | template 7 | void Echo(const T& type) { 8 | std::cout << type; 9 | } 10 | 11 | template 12 | class Value { 13 | public: 14 | T val; 15 | void print() const { std::cout << val << "\n"; } 16 | }; 17 | 18 | 19 | // Explicit instantiation 20 | template void Echo(const int &x); 21 | template void Echo(const std::string &x); 22 | template class Value; 23 | 24 | int main() { 25 | Echo("Hello world: "); 26 | Echo(100); 27 | 28 | Value v; 29 | v.val = 100; 30 | Echo(" Value: "); 31 | v.print(); 32 | return 0; 33 | } -------------------------------------------------------------------------------- /templates/template-pointer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | template 9 | class LongPointer { 10 | public: 11 | LongPointer(T *v) : ptr((unsigned long)v) {} 12 | unsigned long &intValue() { 13 | return ptr; 14 | } 15 | T *ptrValue() { return (T*)ptr; } 16 | private: 17 | unsigned long ptr; 18 | 19 | }; 20 | 21 | int main() { 22 | 23 | 24 | char *value = (char*) std::calloc(1, 100); 25 | sprintf(value, "%s", "Hello World"); 26 | LongPointer ptr(value); 27 | 28 | std::cout << "Integer value for Pointer: " << ptr.intValue() << "\n"; 29 | std::cout << "String value char* ptr: " << (char*)ptr.ptrValue() << "\n"; 30 | 31 | free(value); 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /templates/template-spec.cpp: -------------------------------------------------------------------------------- 1 | /* Example of specialization */ 2 | 3 | 4 | #include 5 | #include 6 | 7 | template 8 | class Value { 9 | public: 10 | T temp; 11 | void print() const; 12 | }; 13 | 14 | template 15 | void Value::print() const { 16 | std::cout << std::dec << temp << "\n"; 17 | } 18 | 19 | template<> 20 | class Value { 21 | public: 22 | void *temp; 23 | void print() const; 24 | }; 25 | 26 | void Value::print() const { 27 | std::cout << "0x" << std::hex << (unsigned long)temp << "\n"; 28 | } 29 | 30 | 31 | template 32 | void Print(Value &type) { 33 | std::cout << "Value: "; 34 | type.print(); 35 | } 36 | 37 | template<> 38 | void Print(Value &v) { 39 | std::cout << "Value: "; 40 | v.print(); 41 | } 42 | 43 | 44 | 45 | int main() { 46 | 47 | Value v; // T is int 48 | v.temp = 100; 49 | v.print(); // print out integer 50 | 51 | Value v2; // specialization 52 | v2.temp = &v; 53 | v2.print(); // print out pointer 54 | 55 | Print(v); // print out Value 56 | Print(v2); // print out Value 57 | 58 | return 0; 59 | } -------------------------------------------------------------------------------- /templates/template-type.cpp: -------------------------------------------------------------------------------- 1 | /* using template type for value */ 2 | 3 | #include 4 | #include 5 | 6 | template 7 | class Temp { 8 | public: 9 | Temp() : val(value) {} 10 | T val; 11 | }; 12 | 13 | int main() { 14 | 15 | // works 16 | Temp t; 17 | std::cout << t.val << "\n"; 18 | 19 | // error 20 | // Temp error_value; 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /templates/template-union.cpp: -------------------------------------------------------------------------------- 1 | /* union templates */ 2 | 3 | #include 4 | 5 | template 6 | union DataArray { 7 | T object; 8 | unsigned char bytes[sizeof(T)]; 9 | }; 10 | 11 | template 12 | std::ostream &operator<<(std::ostream &out, const DataArray &d) { 13 | out << d.object; 14 | return out; 15 | } 16 | 17 | 18 | int main() { 19 | 20 | DataArray value; 21 | DataArray value2; 22 | // manipulate bytes of the integer 23 | value.bytes[0] = 0xFF; 24 | value.bytes[1] = 0xFF; 25 | value.bytes[2] = 0xFF; 26 | value.bytes[3] = 0xFF; 27 | // same as 28 | value2.object = 0xFFFFFFFF; 29 | 30 | 31 | std::cout << value << "\n"; 32 | std::cout << value2 << "\n"; 33 | 34 | 35 | value.bytes[3] = 0; 36 | 37 | std::cout << value << "\n"; 38 | 39 | value.bytes[2] = 0; 40 | 41 | std::cout << value << "\n"; 42 | 43 | value.bytes[1] = 0; 44 | 45 | std::cout << value << "\n"; 46 | 47 | value.bytes[0] = 0; 48 | 49 | std::cout << value << "\n"; 50 | 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /test/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS= -Wall -std=c++11 2 | 3 | all: test1-test st-test type-test temp-test temp-test2 temp-test-2 4 | 5 | test1-test: test.cc 6 | $(CXX) test.cc -o test1-test $(FLAGS) 7 | st-test: static_assert_test.cc 8 | $(CXX) static_assert_test.cc -o st-test $(FLAGS) 9 | type-test: typearr.cc 10 | $(CXX) typearr.cc -o type-test $(FLAGS) 11 | temp-test: temp_test.cc 12 | $(CXX) temp_test.cc -o temp-test $(FLAGS) 13 | temp-test2: temp_test2.cc 14 | $(CXX) temp_test2.cc -o temp-test2 $(FLAGS) 15 | temp-test-2: test2.cc 16 | $(CXX) test2.cc -o temp-test-2 $(FLAGS) 17 | clean: 18 | rm -f test1-test st-test type-test temp-test temp-test2 temp-test-2 19 | 20 | -------------------------------------------------------------------------------- /test/temp_test.cc: -------------------------------------------------------------------------------- 1 | /* 2 | templates as arguments 3 | written by Jared Bruni 4 | http://lostsidedead.com 5 | 6 | */ 7 | 8 | #include 9 | #include 10 | 11 | namespace mx { 12 | 13 | template class C> 14 | class My_List { 15 | public: 16 | My_List() {} 17 | My_List(std::initializer_list t) : arr{t} {} 18 | void print(); 19 | C &container() { return arr; } 20 | protected: 21 | C arr; 22 | }; 23 | 24 | template class C> 25 | void My_List::print() { 26 | for(auto &i : arr) { 27 | std::cout << "List value: " << i << "\n"; 28 | } 29 | } 30 | 31 | template 32 | using My_ListContainer = std::vector; 33 | } 34 | 35 | // simple test of template 36 | int main(int argc, char **argv) { 37 | mx::My_List list1({255, 1024, 2048, 4096}); 38 | list1.print(); 39 | return 0; 40 | 41 | } -------------------------------------------------------------------------------- /test/temp_test2.cc: -------------------------------------------------------------------------------- 1 | /* written by Jared Bruni 2 | http://lostsidedead.com 3 | 4 | */ 5 | 6 | #include 7 | 8 | template 9 | class User { 10 | public: 11 | User() : first{}, last{}, middle{} {} 12 | User(StrType s_first, StrType s_last, StrType s_middle) : first{s_first}, last{s_last}, middle{s_middle} {} 13 | 14 | StrType &firstName() { return first; } 15 | StrType &lastName() { return last; } 16 | StrType &middleName(){ return middle; } 17 | protected: 18 | StrType first, last,middle; 19 | }; 20 | 21 | template 22 | class UserName : public User { 23 | public: 24 | UserName(T first, T last, T middle) : User(first,last,middle) {} 25 | template 26 | void printName(T2 &out) { 27 | out << this->firstName() << ", " << this->lastName() << " , " << this->middleName() << "\n"; 28 | } 29 | }; 30 | 31 | 32 | int main(int argc, char **argv) { 33 | 34 | UserName name("Jared", "Bruni", "P"); 35 | UserName name2(L"Jared", L"Bruni", L"p"); 36 | 37 | name.printName(std::cout); 38 | name2.printName(std::wcout); 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /thought.cc: -------------------------------------------------------------------------------- 1 | // 2 | // Some Thoughts 3 | // written by Jared Bruni 4 | // http://lostsidedead.com 5 | 6 | #include 7 | #include 8 | 9 | template 10 | class Thought { 11 | public: 12 | Thought() = default; 13 | Thought(const T msg) : message {msg} {} 14 | const T &str() const { return message; } 15 | private: 16 | T message; 17 | }; 18 | 19 | template 20 | bool checkIfQuit(T t) { 21 | return false; 22 | } 23 | 24 | bool checkIfQuit(std::string t) { 25 | if(t=="quit") return true; 26 | return false; 27 | } 28 | 29 | template 30 | bool get(Thought &t) { 31 | // process 32 | if(checkIfQuit(t.str()) == true) return false; 33 | return true; 34 | } 35 | 36 | template 37 | Thought &give(Thought &t) { 38 | T token; 39 | std::cin >> token; 40 | t = Thought(token); 41 | return t; 42 | } 43 | 44 | template 45 | void change(Thought &t) { 46 | std::cout << "Karma returns: " << t.str() << "\n"; 47 | } 48 | 49 | int main(int argc, char **argv) 50 | { 51 | Thought thought; 52 | while (get(give(thought))) change(thought); 53 | return 0; 54 | } 55 | 56 | -------------------------------------------------------------------------------- /thread/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS=-Wall -std=c++11 2 | all: thread-test1 async-test async-test2 async-test3 promise-test async-test4 detach-test atomic-test 3 | 4 | thread-test1: thread_test.cc 5 | $(CXX) $(FLAGS) thread_test.cc -o thread-test -pthread 6 | async-test: async_test.cc 7 | $(CXX) $(FLAGS) async_test.cc -o async-test -pthread 8 | async-test2: async_test2.cc 9 | $(CXX) $(FLAGS) async_test2.cc -o async-test2 -pthread 10 | async-test3: async_test3.cc 11 | $(CXX) $(FLAGS) async_test3.cc -o async-test3 -pthread 12 | promise-test: promise.cc 13 | $(CXX) $(FLAGS) promise.cc -o promise-test -pthread 14 | async-test4: async_test4.cpp 15 | $(CXX) $(FLAGS) async_test4.cpp -o async-test4 -pthread 16 | detach-test: detach.cpp 17 | $(CXX) $(FLAGS) detach.cpp -o detach-test -pthread 18 | atomic-test: atomic.cpp 19 | $(CXX) $(FLAGS) atomic.cpp -o atomic-test -pthread 20 | clean: 21 | rm -f thread-test1 async-test async-test2 async-test3 async-test4 promise-test detach-test atomic-test 22 | -------------------------------------------------------------------------------- /thread/async_test2.cc: -------------------------------------------------------------------------------- 1 | /* test of std::future */ 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | int printOut(char c) { 10 | std::default_random_engine dre(static_cast(std::time(0))); 11 | unsigned int num = dre()%100; 12 | for(unsigned int i = 0; i < num; ++i) { 13 | std::cout.put(c).flush(); 14 | } 15 | return num; 16 | } 17 | 18 | int main(int argc, char **argv) { 19 | std::future printNum; 20 | std::cout << "+ for thread1\nx for thread2\n"; 21 | printNum = std::async(printOut, '+'); 22 | int total_value = printOut('x') + printNum.get(); 23 | std::cout << "\nTotal value: " << total_value << "\n"; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /thread/async_test4.cpp: -------------------------------------------------------------------------------- 1 | /* async test 2 | written by Jared Bruni 3 | http://lostsidedead.com 4 | 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | 13 | int getIntegerValue() { 14 | int x; 15 | std::cout << "Enter integer value: "; 16 | std::cin >> x; 17 | return x; 18 | } 19 | 20 | int main(int argc, char **argv) { 21 | 22 | 23 | std::future f = std::async(getIntegerValue); 24 | int value = f.get(); 25 | std::cout << "Value Entered is: " << value << "\n"; 26 | f = std::async(getIntegerValue); 27 | std::cout << "Value is: " << f.get() << "\n"; 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /thread/atomic.cpp: -------------------------------------------------------------------------------- 1 | /* C++11 atomic example 2 | written by Jared Bruni 3 | http://lostsidedead.com 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | 12 | std::atomic value; // value can be used by both threads without worry 13 | 14 | void thread1() { 15 | // testing value 16 | while(value != 1) { 17 | std::cout << "Checking Values...\n"; 18 | } 19 | std::cout << "value changed.\n"; 20 | } 21 | 22 | void thread2() { 23 | sleep(2); 24 | // set the value 25 | value = 1; 26 | } 27 | 28 | 29 | int main(int argc, char **argv) { 30 | 31 | std::cout << "adding threads..\n"; 32 | // creating the threads 33 | std::thread t1(thread1); 34 | std::thread t2(thread2); 35 | 36 | 37 | // wait for the threads to finish before exiting 38 | t1.join(); 39 | t2.join(); 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /thread/detach.cpp: -------------------------------------------------------------------------------- 1 | /* deatch test 2 | written by Jared Bruni 3 | 4 | http://lostsidedead.com 5 | 6 | */ 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | std::mutex m; 14 | 15 | void background_Thread() { 16 | std::default_random_engine dre(static_cast(time(0))); 17 | std::this_thread::sleep_for(std::chrono::seconds(dre()%2)); 18 | std::lock_guard lock(m); 19 | std::cout << "Woke up" << "\n"; 20 | } 21 | 22 | int main(int argc, char **argv) { 23 | 24 | for(unsigned int i = 0; i < 10; ++i) { 25 | std::thread t(background_Thread); 26 | t.detach(); 27 | } 28 | 29 | std::this_thread::sleep_for(std::chrono::seconds(4)); 30 | std::cout << "Exiting...\n"; 31 | 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /thread/thread_test.cc: -------------------------------------------------------------------------------- 1 | // 2 | // 3 | // Created by Jared Bruni on 7/9/13. 4 | // 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | std::mutex mut; 11 | 12 | class Background { 13 | int id; 14 | public: 15 | Background(int id) { 16 | this->id = id; 17 | } 18 | void operator()() { 19 | for(int i = 0; i < 100; ++i) { 20 | mut.lock(); 21 | std::cout << "Background thread: " << id << "\n"; 22 | mut.unlock(); 23 | } 24 | } 25 | }; 26 | 27 | 28 | int main(int argc, char **argv) 29 | { 30 | std::cout << "start.\n"; 31 | Background back(0), back2(1); 32 | std::thread t(back); 33 | std::thread t2(back2); 34 | 35 | std::thread lamb_thread([]() { 36 | 37 | for(int i = 0; i < 100; ++i) { 38 | mut.lock(); 39 | std::cout << "Here\n"; 40 | mut.unlock(); 41 | } 42 | 43 | }); 44 | 45 | t.join(); 46 | t2.join(); 47 | lamb_thread.join(); 48 | 49 | return 0; 50 | } 51 | 52 | -------------------------------------------------------------------------------- /tilemap/Makefile: -------------------------------------------------------------------------------- 1 | 2 | 3 | all: tile-test 4 | 5 | tile-test: main.cpp 6 | $(CXX) main.cpp -o tile-test -std=c++11 7 | clean: 8 | rm -f tile-test 9 | -------------------------------------------------------------------------------- /tilemap/TileMap2/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | 3 | all: 4 | $(CXX) main.cpp -o test -std=c++11 5 | -------------------------------------------------------------------------------- /tilemap/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // TileCore 4 | // 5 | // Created by Jared Bruni on 6/19/13. 6 | // Copyright (c) 2013 Jared Bruni. All rights reserved. 7 | // 8 | 9 | #include 10 | #include "Tilemap.h" 11 | 12 | class Bitmap {}; 13 | 14 | void draw(int x, int y, mx::Tile &b) { 15 | 16 | std::cout << "Draw at x,y " << x << ", " << y << "\n"; 17 | } 18 | 19 | int main(int argc, const char * argv[]) 20 | { 21 | try { 22 | 23 | mx::TileMap> map(640/4, 480/4); 24 | 25 | for(signed int x = 0; x < map.width(); ++x) { 26 | for(signed int y = 0; y < map.height(); ++y) { 27 | 28 | mx::Tile &b = map.at(x,y); 29 | draw(x,y,b); 30 | } 31 | } 32 | } 33 | catch (mx::OutOfRange_Exception &e) { 34 | std::cout << e.what() << "\n"; 35 | } 36 | catch (...) { 37 | std::cerr << "Error \n"; 38 | } 39 | // insert code here... 40 | std::cout << "Hello, World!\n"; 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /tilemap/newtilemap/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | newtilemap 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.cdt.managedbuilder.core.genmakebuilder 10 | clean,full,incremental, 11 | 12 | 13 | 14 | 15 | org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder 16 | full,incremental, 17 | 18 | 19 | 20 | 21 | 22 | org.eclipse.cdt.core.cnature 23 | org.eclipse.cdt.core.ccnature 24 | org.eclipse.cdt.managedbuilder.core.managedBuildNature 25 | org.eclipse.cdt.managedbuilder.core.ScannerConfigNature 26 | 27 | 28 | -------------------------------------------------------------------------------- /tilemap/newtilemap/newtilemap/newtilemap.xcodeproj/project.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /tilemap/newtilemap/newtilemap/newtilemap.xcodeproj/project.xcworkspace/xcuserdata/jared.xcuserdatad/UserInterfaceState.xcuserstate: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/tilemap/newtilemap/newtilemap/newtilemap.xcodeproj/project.xcworkspace/xcuserdata/jared.xcuserdatad/UserInterfaceState.xcuserstate -------------------------------------------------------------------------------- /tilemap/newtilemap/newtilemap/newtilemap.xcodeproj/xcuserdata/jared.xcuserdatad/xcschemes/xcschememanagement.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | SchemeUserState 6 | 7 | newtilemap.xcscheme 8 | 9 | orderHint 10 | 0 11 | 12 | 13 | SuppressBuildableAutocreation 14 | 15 | 7F5ED7AC17B6D7D300A36F9D 16 | 17 | primary 18 | 19 | 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /tilemap/newtilemap/newtilemap/newtilemap/sdltest/Makefile: -------------------------------------------------------------------------------- 1 | CXX=clang++ 2 | SDL_CONFIG_PATH=/opt/local/bin 3 | FLAGS= -std=c++11 `$(SDL_CONFIG_PATH)/sdl-config --cflags --static-libs` 4 | 5 | all: 6 | $(CXX) test.cpp -o sdl-test $(FLAGS) 7 | clean: 8 | rm -f sdl-test 9 | -------------------------------------------------------------------------------- /tilemap/test: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/tilemap/test -------------------------------------------------------------------------------- /tokenize/Makefile: -------------------------------------------------------------------------------- 1 | CXXFLAGS=-std=c++11 2 | SOURCE=tokenize.cpp 3 | COLLECT_SOURCE=collect_tokens.cpp 4 | OUTPUT=tokenize-test 5 | COLLECT_OUTPUT=collect-test 6 | PARSE_SOURCE=parse.cpp 7 | PARSE_OUTPUT=parse-test 8 | all: $(OUTPUT) $(COLLECT_OUTPUT) $(PARSE_OUTPUT) 9 | 10 | $(OUTPUT): $(SOURCE) 11 | $(CXX) $(CXXFLAGS) $(SOURCE) -o $(OUTPUT) 12 | $(COLLECT_OUTPUT): $(COLLECT_SOURCE) 13 | $(CXX) $(CXXFLAGS) $(COLLECT_SOURCE) -o $(COLLECT_OUTPUT) 14 | $(PARSE_OUTPUT): $(PARSE_SOURCE) 15 | $(CXX) $(CXXFLAGS) $(PARSE_SOURCE) -o $(PARSE_OUTPUT) 16 | clean: 17 | rm -f $(OUTPUT) $(COLLECT_OUTPUT) $(PARSE_OUTPUT) 18 | -------------------------------------------------------------------------------- /tokenize/collect_tokens.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include"lexer.hpp" 7 | 8 | void processTokens(std::vector &t) { 9 | for(auto it = t.begin(), stop = t.end(); it != stop; ++it) { 10 | std::cout << *it << "\n"; 11 | } 12 | } 13 | 14 | int main(int argc, char **argv) { 15 | if(argc != 2) { 16 | std::cerr << "Program takes one argument of source file..\n"; 17 | return 0; 18 | } 19 | std::vector tokens; 20 | 21 | try { 22 | std::fstream file; 23 | file.open(argv[1], std::ios::in); 24 | if(!file.is_open()) { 25 | std::cerr << "Error could not open file: " << argv[1] << "\n"; 26 | } 27 | lex::Scanner scan(file); 28 | while(scan.valid()) { 29 | lex::Token token; 30 | scan >> token; 31 | tokens.push_back(token); 32 | } 33 | file.close(); 34 | processTokens(tokens); 35 | } 36 | catch(lex::Scanner_EOF) { 37 | std::cerr << "EOF.\n\n"; 38 | } 39 | catch(lex::Scanner_Error) { 40 | std::cerr << "Scanner Error Occured..\n"; 41 | } 42 | return 0; 43 | } -------------------------------------------------------------------------------- /transfer/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CXX_FLAGS= -Wall -O3 -std=c++11 3 | 4 | all: transfer-tool 5 | 6 | transfer-tool: transfer.cc 7 | $(CXX) transfer.cc -o transfer-tool $(CXX_FLAGS) -pthread 8 | 9 | clean: 10 | rm -f transfer-tool 11 | 12 | -------------------------------------------------------------------------------- /trim_lines/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | CXX_FLAGS=-std=c++11 3 | OBJECT_SOURCE=triml 4 | 5 | all: $(OBJECT_SOURCE) 6 | 7 | $(OBJECT_SOURCE): $(OBJECT_SOURCE).cpp 8 | $(CXX) $(CXX_FLAGS) $(OBJECT_SOURCE).cpp -o $(OBJECT_SOURCE) 9 | clean: 10 | rm -f $(OBJECT_SOURCE) 11 | install: 12 | cp $(OBJECT_SOURCE) /usr/local/bin 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /trim_lines/triml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lostjared/cplusplus11.Examples/714d43f47c081f8127c23828a509edcc8bc06d48/trim_lines/triml -------------------------------------------------------------------------------- /trim_lines/triml.cpp.txt: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | bool containsData(const std::string &text) { 6 | for(auto &i : text) { 7 | if(i != ' ' && i != '\n' && i != '\r' && i != '\t') return true; 8 | } 9 | return false; 10 | } 11 | int main(int argc, char **argv) { 12 | if(argc != 2) { 13 | std::cerr << "Requires one argument the txt file.\n"; 14 | return 0; 15 | } 16 | std::fstream file; 17 | file.open(argv[1], std::ios::in); 18 | if(!file.is_open()) { 19 | std::cerr << "Error opening file: "<0 && containsData(n)) { 35 | ofile << n << "\n"; 36 | } 37 | } 38 | ofile.close(); 39 | file.close(); 40 | std::cout << "Outputed: " << ofile_n << "\n"; 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /try/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS=-Wall -std=c++11 2 | 3 | all: try-test try-test2 4 | 5 | try-test: try.cc 6 | $(CXX) try.cc -o try-test $(CFLAGS) 7 | try-test2: try2.cc 8 | $(CXX) try2.cc -o try-test2 $(CFLAGS) 9 | clean: 10 | rm -rf try-test try-test2 11 | -------------------------------------------------------------------------------- /try/try.cc: -------------------------------------------------------------------------------- 1 | /* This seems odd to me but it works, instead of a regular block 2 | we can use a try block instead */ 3 | 4 | #include 5 | 6 | 7 | void function(int x) 8 | try { 9 | std::cout << x << " is the value\n"; 10 | throw 1; 11 | } 12 | catch(...) { 13 | std::cerr << "Error \n"; 14 | } 15 | 16 | 17 | class Value { 18 | public: 19 | Value() = default; 20 | 21 | void pass(int x) 22 | try { 23 | function(x); 24 | function(20); 25 | } catch(...) { 26 | 27 | } 28 | }; 29 | 30 | int main() 31 | try { 32 | std::cout << "Example Try blocks\nEnter something:\n"; 33 | Value v; 34 | int x; 35 | std::cin >> x; 36 | v.pass(x); 37 | return 0; 38 | } 39 | catch(std::exception &e) { 40 | 41 | return -1; 42 | } 43 | catch(...) { 44 | 45 | return -1; 46 | } 47 | 48 | 49 | -------------------------------------------------------------------------------- /try/try2.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class Exit {}; 4 | 5 | auto writeToOutput(std::string s) -> int try { 6 | std::cout << "String value is: " << s << "\n"; 7 | return 0; 8 | } catch(...) { 9 | return 1; 10 | } 11 | 12 | int main(int argc, char **argv) try { 13 | std::cout << "Enter variable: "; 14 | std::string s; 15 | std::cin >> s; 16 | if(s == "quit") { 17 | throw Exit(); 18 | } 19 | return writeToOutput(s); 20 | } 21 | catch(Exit) { 22 | std::cout << "You entered quit.\n"; 23 | return 0; 24 | } 25 | catch(...) { 26 | return -1; 27 | } -------------------------------------------------------------------------------- /tuple/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS= -Wall -std=c++11 3 | 4 | all: tuple-test 5 | 6 | tuple-test: t.cc 7 | $(CXX) t.cc -o tuple-test $(FLAGS) 8 | clean: 9 | rm -f tuple-test 10 | -------------------------------------------------------------------------------- /typeid/Makefile: -------------------------------------------------------------------------------- 1 | 2 | FLAGS= -Wall -std=c++11 3 | 4 | all: typeid-test typeid-test2 5 | 6 | typeid-test: typeid_test.cc 7 | $(CXX) typeid_test.cc -o typeid-test $(FLAGS) 8 | typeid-test2: typeid_test2.cpp 9 | $(CXX) typeid_test2.cpp -o typeid-test2 $(FLAGS) 10 | clean: 11 | rm -f typeid-test typeid-test2 12 | -------------------------------------------------------------------------------- /typeid/typeid_test2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | class Id { 6 | public: 7 | std::string first, last; 8 | int number; 9 | }; 10 | 11 | class FullID : public Id { 12 | public: 13 | std::string address; 14 | 15 | }; 16 | 17 | int main() { 18 | 19 | Id i; 20 | FullID i2; 21 | 22 | std::cout << typeid(i).name() << "\n"; 23 | std::cout << typeid(i2).name() << "\n"; 24 | 25 | if(typeid(i).name()==typeid(i2).name()) { 26 | std::cout << "Same type\n"; 27 | } 28 | else { 29 | std::cout << "Not the same type.\n"; 30 | } 31 | 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /unordered_map/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS=-Wall -std=c++11 2 | all: unordered-test test2 3 | 4 | unordered-test: unordered_map_test.cc 5 | $(CXX) unordered_map_test.cc -o unordered-test $(FLAGS) 6 | test2: print_recursive.cc 7 | $(CXX) print_recursive.cc -o test2 $(FLAGS) 8 | clean: 9 | rm -rf unordered-test test2 10 | -------------------------------------------------------------------------------- /unordered_map/print_recursive.cc: -------------------------------------------------------------------------------- 1 | // recursion 2 | // Created by Jared Bruni on 7/14/13. 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | void PrintMap(std::unordered_map &m, std::unordered_map::iterator map_iterator) { 11 | 12 | std::cout << map_iterator->first << ": " << map_iterator->second; 13 | 14 | map_iterator++; 15 | if(map_iterator == m.end()) 16 | return; 17 | 18 | PrintMap(m, map_iterator); // recursive 19 | } 20 | 21 | 22 | int main(int argc, char **argv) { 23 | std::unordered_map test; 24 | for (auto s : { "String1", "String2", "Jared", "Adding Stuff", "To the Map" }) { 25 | std::ostringstream stream; 26 | stream << s << ": is the value here\n"; 27 | test[s] = stream.str(); 28 | } 29 | // print map with recursion 30 | 31 | PrintMap(test, test.begin()); 32 | 33 | // print a string 34 | 35 | std::cout << test["String1"] << " \n"; 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /variadic/Makefile: -------------------------------------------------------------------------------- 1 | FLAGS=-Wall -std=c++11 2 | 3 | all: vari-test vari-test2 4 | 5 | vari-test: v.cc 6 | $(CXX) v.cc -o vari-test $(FLAGS) 7 | vari-test2: v2.cc 8 | $(CXX) v2.cc -o vari-test2 $(FLAGS) 9 | clean: 10 | rm -f vari-test vari-test2 11 | -------------------------------------------------------------------------------- /variadic/v.cc: -------------------------------------------------------------------------------- 1 | /* 2 | Variadic template printf 3 | written by Jared Bruni 4 | http://lostsidedead.com 5 | */ 6 | 7 | #include 8 | 9 | namespace mx { 10 | 11 | void printf(const char *s) { 12 | if(s == nullptr) return; 13 | while(*s) { 14 | std::cout << *s++; 15 | } 16 | } 17 | 18 | template 19 | void printf(const char *s, T value, Args... args) { 20 | while(s && *s) { 21 | if(*s == '%' && *++s!='%') { 22 | std::cout << value; 23 | return printf(++s, args...); 24 | } 25 | std::cout << *s++; 26 | } 27 | throw std::runtime_error("Extra arguments...\n"); 28 | } 29 | } 30 | 31 | 32 | int main(int argc, char **argv) { 33 | try { 34 | std::string temp = "from Jared"; 35 | mx::printf("Hello world %s %d : %d\n Test.\n",temp,640, 480); 36 | } 37 | catch(std::exception &e) { 38 | std::cerr << e.what() << "\n"; 39 | } 40 | return 0; 41 | } -------------------------------------------------------------------------------- /variadic/v2.cc: -------------------------------------------------------------------------------- 1 | /* Variadic template 2 | written by Jared Bruni 3 | http://lostsidedead.com 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | 10 | 11 | class Point { public: int x, y; }; 12 | class Rect { public: Point p1, p2; }; 13 | class Text { public: Point pos; std::string text; }; 14 | 15 | 16 | std::ostream &operator<<(std::ostream &out, Point &p) { 17 | out << p.x << ", " << p.y << " "; 18 | return out; 19 | } 20 | 21 | // variable number of bases 22 | 23 | template 24 | class Test : public BaseTypes... { 25 | public: 26 | Test(const BaseTypes&... b) : BaseTypes(b)... {} 27 | size_t sizeTypes() { return sizeof...(BaseTypes); } 28 | 29 | }; 30 | 31 | int main(int argc, char **argv) { 32 | try { 33 | Test test1({0,0}); 34 | Test test2({0,0}, {{0,0},{640,480}}); 35 | Test test3({0,0}, {{0,0},{480,272}}, {{25,25}, {"Hello world Test"}}); 36 | 37 | std::cout << "sizeof... " << test3.sizeTypes() << " Text: " << test3.text << "\n"; 38 | std::cout << "Points: " << test3.p1 << test3.p2 << "\n"; 39 | } 40 | catch(std::exception &e) { 41 | std::cerr << e.what() << "\n"; 42 | } 43 | return 0; 44 | } -------------------------------------------------------------------------------- /vector/Makefile: -------------------------------------------------------------------------------- 1 | CXX=c++ 2 | FLAGS=-std=c++11 3 | 4 | all: persist-test em-test 5 | 6 | persist-test: persist_vector.cc 7 | $(CXX) -Wall $(FLAGS) persist_vector.cc -o persist-test 8 | em-test: em.cc 9 | $(CXX) -Wall $(FLAGS) em.cc -o em-test 10 | clean: 11 | rm -f persist-test 12 | rm -f em-test 13 | --------------------------------------------------------------------------------