C++ Programming
made by https://0x3d.site
GitHub - p-ranav/argparse: Argument Parser for Modern C++Argument Parser for Modern C++. Contribute to p-ranav/argparse development by creating an account on GitHub.
Visit Site
GitHub - p-ranav/argparse: Argument Parser for Modern C++
Highlights
- Single header file
- Requires C++17
- MIT License
Table of Contents
- Quick Start
- Positional Arguments
- Optional Arguments
- Storing values into variables
- Negative Numbers
- Combining Positional and Optional Arguments
- Printing Help
- Adding a description and an epilog to help
- List of Arguments
- Compound Arguments
- Converting to Numeric Types
- Default Arguments
- Gathering Remaining Arguments
- Parent Parsers
- Subcommands
- Getting Argument and Subparser Instances
- Parse Known Args
- Hidden argument and alias
- ArgumentParser in bool Context
- Custom Prefix Characters
- Custom Assignment Characters
- Further Examples
- Developer Notes
- CMake Integration
- Building, Installing, and Testing
- Supported Toolchains
- Contributing
- License
Quick Start
Simply include argparse.hpp and you're good to go.
#include <argparse/argparse.hpp>
To start parsing command-line arguments, create an ArgumentParser
.
argparse::ArgumentParser program("program_name");
NOTE: There is an optional second argument to the ArgumentParser
which is the program version. Example: argparse::ArgumentParser program("libfoo", "1.9.0");
NOTE: There are optional third and fourth arguments to the ArgumentParser
which control default arguments. Example: argparse::ArgumentParser program("libfoo", "1.9.0", default_arguments::help, false);
See Default Arguments, below.
To add a new argument, simply call .add_argument(...)
. You can provide a variadic list of argument names that you want to group together, e.g., -v
and --verbose
program.add_argument("foo");
program.add_argument("-v", "--verbose"); // parameter packing
Argparse supports a variety of argument types including positional, optional, and compound arguments. Below you can see how to configure each of these types:
Positional Arguments
Here's an example of a positional argument:
#include <argparse/argparse.hpp>
int main(int argc, char *argv[]) {
argparse::ArgumentParser program("program_name");
program.add_argument("square")
.help("display the square of a given integer")
.scan<'i', int>();
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
return 1;
}
auto input = program.get<int>("square");
std::cout << (input * input) << std::endl;
return 0;
}
And running the code:
foo@bar:/home/dev/$ ./main 15
225
Here's what's happening:
- The
add_argument()
method is used to specify which command-line options the program is willing to accept. In this case, I’ve named it square so that it’s in line with its function. - Command-line arguments are strings. To square the argument and print the result, we need to convert this argument to a number. In order to do this, we use the
.scan
method to convert user input into an integer. - We can get the value stored by the parser for a given argument using
parser.get<T>(key)
method.
Optional Arguments
Now, let's look at optional arguments. Optional arguments start with -
or --
, e.g., --verbose
or -a
. Optional arguments can be placed anywhere in the input sequence.
argparse::ArgumentParser program("test");
program.add_argument("--verbose")
.help("increase output verbosity")
.default_value(false)
.implicit_value(true);
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
if (program["--verbose"] == true) {
std::cout << "Verbosity enabled" << std::endl;
}
foo@bar:/home/dev/$ ./main --verbose
Verbosity enabled
Here's what's happening:
- The program is written so as to display something when --verbose is specified and display nothing when not.
- Since the argument is actually optional, no error is thrown when running the program without
--verbose
. Note that by using.default_value(false)
, if the optional argument isn’t used, it's value is automatically set to false. - By using
.implicit_value(true)
, the user specifies that this option is more of a flag than something that requires a value. When the user provides the --verbose option, it's value is set to true.
Flag
When defining flag arguments, you can use the shorthand flag()
which is the same as default_value(false).implicit_value(true)
.
argparse::ArgumentParser program("test");
program.add_argument("--verbose")
.help("increase output verbosity")
.flag();
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
if (program["--verbose"] == true) {
std::cout << "Verbosity enabled" << std::endl;
}
Requiring optional arguments
There are scenarios where you would like to make an optional argument required. As discussed above, optional arguments either begin with -
or --
. You can make these types of arguments required like so:
program.add_argument("-o", "--output")
.required()
.help("specify the output file.");
If the user does not provide a value for this parameter, an exception is thrown.
Alternatively, you could provide a default value like so:
program.add_argument("-o", "--output")
.default_value(std::string("-"))
.required()
.help("specify the output file.");
Accessing optional arguments without default values
If you require an optional argument to be present but have no good default value for it, you can combine testing and accessing the argument as following:
if (auto fn = program.present("-o")) {
do_something_with(*fn);
}
Similar to get
, the present
method also accepts a template argument. But rather than returning T
, parser.present<T>(key)
returns std::optional<T>
, so that when the user does not provide a value to this parameter, the return value compares equal to std::nullopt
.
Deciding if the value was given by the user
If you want to know whether the user supplied a value for an argument that has a .default_value
, check whether the argument .is_used()
.
program.add_argument("--color")
.default_value(std::string{"orange"}) // might otherwise be type const char* leading to an error when trying program.get<std::string>
.help("specify the cat's fur color");
try {
program.parse_args(argc, argv); // Example: ./main --color orange
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto color = program.get<std::string>("--color"); // "orange"
auto explicit_color = program.is_used("--color"); // true, user provided orange
Joining values of repeated optional arguments
You may want to allow an optional argument to be repeated and gather all values in one place.
program.add_argument("--color")
.default_value<std::vector<std::string>>({ "orange" })
.append()
.help("specify the cat's fur color");
try {
program.parse_args(argc, argv); // Example: ./main --color red --color green --color blue
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto colors = program.get<std::vector<std::string>>("--color"); // {"red", "green", "blue"}
Notice that .default_value
is given an explicit template parameter to match the type you want to .get
.
Repeating an argument to increase a value
A common pattern is to repeat an argument to indicate a greater value.
int verbosity = 0;
program.add_argument("-V", "--verbose")
.action([&](const auto &) { ++verbosity; })
.append()
.default_value(false)
.implicit_value(true)
.nargs(0);
program.parse_args(argc, argv); // Example: ./main -VVVV
std::cout << "verbose level: " << verbosity << std::endl; // verbose level: 4
Mutually Exclusive Group
Create a mutually exclusive group using program.add_mutually_exclusive_group(required = false)
. `argparse`` will make sure that only one of the arguments in the mutually exclusive group was present on the command line:
auto &group = program.add_mutually_exclusive_group();
group.add_argument("--first");
group.add_argument("--second");
with the following usage will yield an error:
foo@bar:/home/dev/$ ./main --first 1 --second 2
Argument '--second VAR' not allowed with '--first VAR'
The add_mutually_exclusive_group()
function also accepts a required
argument, to indicate that at least one of the mutually exclusive arguments is required:
auto &group = program.add_mutually_exclusive_group(true);
group.add_argument("--first");
group.add_argument("--second");
with the following usage will yield an error:
foo@bar:/home/dev/$ ./main
One of the arguments '--first VAR' or '--second VAR' is required
Storing values into variables
It is possible to bind arguments to a variable storing their value, as an
alternative to explicitly calling program.get<T>(arg_name)
or program[arg_name]
This is currently implementeted for variables of type bool
(this also
implicitly calls flag()
), int
, double
, std::string
,
std::vector<std::string>
and std::vector<int>
.
If the argument is not specified in the command
line, the default value (if set) is set into the variable.
bool flagvar = false;
program.add_argument("--flagvar").store_into(flagvar);
int intvar = 0;
program.add_argument("--intvar").store_into(intvar);
double doublevar = 0;
program.add_argument("--doublevar").store_into(doublevar);
std::string strvar;
program.add_argument("--strvar").store_into(strvar);
std::vector<std::string> strvar_repeated;
program.add_argument("--strvar-repeated").append().store_into(strvar_repeated);
std::vector<std::string> strvar_multi_valued;
program.add_argument("--strvar-multi-valued").nargs(2).store_into(strvar_multi_valued);
std::vector<int> intvar_repeated;
program.add_argument("--intvar-repeated").append().store_into(intvar_repeated);
std::vector<int> intvar_multi_valued;
program.add_argument("--intvar-multi-valued").nargs(2).store_into(intvar_multi_valued);
Negative Numbers
Optional arguments start with -
. Can argparse
handle negative numbers? The answer is yes!
argparse::ArgumentParser program;
program.add_argument("integer")
.help("Input number")
.scan<'i', int>();
program.add_argument("floats")
.help("Vector of floats")
.nargs(4)
.scan<'g', float>();
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
// Some code to print arguments
foo@bar:/home/dev/$ ./main -5 -1.1 -3.1415 -3.1e2 -4.51329E3
integer : -5
floats : -1.1 -3.1415 -310 -4513.29
As you can see here, argparse
supports negative integers, negative floats and scientific notation.
Combining Positional and Optional Arguments
argparse::ArgumentParser program("main");
program.add_argument("square")
.help("display the square of a given number")
.scan<'i', int>();
program.add_argument("--verbose")
.default_value(false)
.implicit_value(true);
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
int input = program.get<int>("square");
if (program["--verbose"] == true) {
std::cout << "The square of " << input << " is " << (input * input) << std::endl;
}
else {
std::cout << (input * input) << std::endl;
}
foo@bar:/home/dev/$ ./main 4
16
foo@bar:/home/dev/$ ./main 4 --verbose
The square of 4 is 16
foo@bar:/home/dev/$ ./main --verbose 4
The square of 4 is 16
Printing Help
std::cout << program
prints a help message, including the program usage and information about the arguments registered with the ArgumentParser
. For the previous example, here's the default help message:
foo@bar:/home/dev/$ ./main --help
Usage: main [-h] [--verbose] square
Positional arguments:
square display the square of a given number
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
--verbose
You may also get the help message in string via program.help().str()
.
Adding a description and an epilog to help
ArgumentParser::add_description
will add text before the detailed argument
information. ArgumentParser::add_epilog
will add text after all other help output.
#include <argparse/argparse.hpp>
int main(int argc, char *argv[]) {
argparse::ArgumentParser program("main");
program.add_argument("thing").help("Thing to use.").metavar("THING");
program.add_argument("--member").help("The alias for the member to pass to.").metavar("ALIAS");
program.add_argument("--verbose").default_value(false).implicit_value(true);
program.add_description("Forward a thing to the next member.");
program.add_epilog("Possible things include betingalw, chiz, and res.");
program.parse_args(argc, argv);
std::cout << program << std::endl;
}
Usage: main [-h] [--member ALIAS] [--verbose] THING
Forward a thing to the next member.
Positional arguments:
THING Thing to use.
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
--member ALIAS The alias for the member to pass to.
--verbose
Possible things include betingalw, chiz, and res.
List of Arguments
ArgumentParser objects usually associate a single command-line argument with a single action to be taken. The .nargs
associates a different number of command-line arguments with a single action. When using nargs(N)
, N arguments from the command line will be gathered together into a list.
argparse::ArgumentParser program("main");
program.add_argument("--input_files")
.help("The list of input files")
.nargs(2);
try {
program.parse_args(argc, argv); // Example: ./main --input_files config.yml System.xml
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto files = program.get<std::vector<std::string>>("--input_files"); // {"config.yml", "System.xml"}
ArgumentParser.get<T>()
has specializations for std::vector
and std::list
. So, the following variant, .get<std::list>
, will also work.
auto files = program.get<std::list<std::string>>("--input_files"); // {"config.yml", "System.xml"}
Using .scan
, one can quickly build a list of desired value types from command line arguments. Here's an example:
argparse::ArgumentParser program("main");
program.add_argument("--query_point")
.help("3D query point")
.nargs(3)
.default_value(std::vector<double>{0.0, 0.0, 0.0})
.scan<'g', double>();
try {
program.parse_args(argc, argv); // Example: ./main --query_point 3.5 4.7 9.2
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto query_point = program.get<std::vector<double>>("--query_point"); // {3.5, 4.7, 9.2}
You can also make a variable length list of arguments with the .nargs
.
Below are some examples.
program.add_argument("--input_files")
.nargs(1, 3); // This accepts 1 to 3 arguments.
Some useful patterns are defined like "?", "*", "+" of argparse in Python.
program.add_argument("--input_files")
.nargs(argparse::nargs_pattern::any); // "*" in Python. This accepts any number of arguments including 0.
program.add_argument("--input_files")
.nargs(argparse::nargs_pattern::at_least_one); // "+" in Python. This accepts one or more number of arguments.
program.add_argument("--input_files")
.nargs(argparse::nargs_pattern::optional); // "?" in Python. This accepts an argument optionally.
Compound Arguments
Compound arguments are optional arguments that are combined and provided as a single argument. Example: ps -aux
argparse::ArgumentParser program("test");
program.add_argument("-a")
.default_value(false)
.implicit_value(true);
program.add_argument("-b")
.default_value(false)
.implicit_value(true);
program.add_argument("-c")
.nargs(2)
.default_value(std::vector<float>{0.0f, 0.0f})
.scan<'g', float>();
try {
program.parse_args(argc, argv); // Example: ./main -abc 1.95 2.47
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto a = program.get<bool>("-a"); // true
auto b = program.get<bool>("-b"); // true
auto c = program.get<std::vector<float>>("-c"); // {1.95, 2.47}
/// Some code that prints parsed arguments
foo@bar:/home/dev/$ ./main -ac 3.14 2.718
a = true
b = false
c = {3.14, 2.718}
foo@bar:/home/dev/$ ./main -cb
a = false
b = true
c = {0.0, 0.0}
Here's what's happening:
- We have three optional arguments
-a
,-b
and-c
. -a
and-b
are toggle arguments.-c
requires 2 floating point numbers from the command-line.- argparse can handle compound arguments, e.g.,
-abc
or-bac
or-cab
. This only works with short single-character argument names.-a
and-b
become true.- argv is further parsed to identify the inputs mapped to
-c
. - If argparse cannot find any arguments to map to c, then c defaults to {0.0, 0.0} as defined by
.default_value
Converting to Numeric Types
For inputs, users can express a primitive type for the value.
The .scan<Shape, T>
method attempts to convert the incoming std::string
to T
following the Shape
conversion specifier. An std::invalid_argument
or std::range_error
exception is thrown for errors.
program.add_argument("-x")
.scan<'d', int>();
program.add_argument("scale")
.scan<'g', double>();
Shape
specifies what the input "looks like", and the type template argument specifies the return value of the predefined action. Acceptable types are floating point (i.e float, double, long double) and integral (i.e. signed char, short, int, long, long long).
The grammar follows std::from_chars
, but does not exactly duplicate it. For example, hexadecimal numbers may begin with 0x
or 0X
and numbers with a leading zero may be handled as octal values.
Shape | interpretation |
---|---|
'a' or 'A' | hexadecimal floating point |
'e' or 'E' | scientific notation (floating point) |
'f' or 'F' | fixed notation (floating point) |
'g' or 'G' | general form (either fixed or scientific) |
'd' | decimal |
'i' | std::from_chars grammar with base == 10 |
'o' | octal (unsigned) |
'u' | decimal (unsigned) |
'x' or 'X' | hexadecimal (unsigned) |
Default Arguments
argparse
provides predefined arguments and actions for -h
/--help
and -v
/--version
. By default, these actions will exit the program after displaying a help or version message, respectively. This exit does not call destructors, skipping clean-up of taken resources.
These default arguments can be disabled during ArgumentParser
creation so that you can handle these arguments in your own way. (Note that a program name and version must be included when choosing default arguments.)
argparse::ArgumentParser program("test", "1.0", default_arguments::none);
program.add_argument("-h", "--help")
.action([=](const std::string& s) {
std::cout << help().str();
})
.default_value(false)
.help("shows help message")
.implicit_value(true)
.nargs(0);
The above code snippet outputs a help message and continues to run. It does not support a --version
argument.
The default is default_arguments::all
for included arguments. No default arguments will be added with default_arguments::none
. default_arguments::help
and default_arguments::version
will individually add --help
and --version
.
The default arguments can be used while disabling the default exit with these arguments. This forth argument to ArgumentParser
(exit_on_default_arguments
) is a bool flag with a default true value. The following call will retain --help
and --version
, but will not exit when those arguments are used.
argparse::ArgumentParser program("test", "1.0", default_arguments::all, false)
Gathering Remaining Arguments
argparse
supports gathering "remaining" arguments at the end of the command, e.g., for use in a compiler:
foo@bar:/home/dev/$ compiler file1 file2 file3
To enable this, simply create an argument and mark it as remaining
. All remaining arguments passed to argparse are gathered here.
argparse::ArgumentParser program("compiler");
program.add_argument("files")
.remaining();
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
try {
auto files = program.get<std::vector<std::string>>("files");
std::cout << files.size() << " files provided" << std::endl;
for (auto& file : files)
std::cout << file << std::endl;
} catch (std::logic_error& e) {
std::cout << "No files provided" << std::endl;
}
When no arguments are provided:
foo@bar:/home/dev/$ ./compiler
No files provided
and when multiple arguments are provided:
foo@bar:/home/dev/$ ./compiler foo.txt bar.txt baz.txt
3 files provided
foo.txt
bar.txt
baz.txt
The process of gathering remaining arguments plays nicely with optional arguments too:
argparse::ArgumentParser program("compiler");
program.add_arguments("-o")
.default_value(std::string("a.out"));
program.add_argument("files")
.remaining();
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto output_filename = program.get<std::string>("-o");
std::cout << "Output filename: " << output_filename << std::endl;
try {
auto files = program.get<std::vector<std::string>>("files");
std::cout << files.size() << " files provided" << std::endl;
for (auto& file : files)
std::cout << file << std::endl;
} catch (std::logic_error& e) {
std::cout << "No files provided" << std::endl;
}
foo@bar:/home/dev/$ ./compiler -o main foo.cpp bar.cpp baz.cpp
Output filename: main
3 files provided
foo.cpp
bar.cpp
baz.cpp
NOTE: Remember to place all optional arguments BEFORE the remaining argument. If the optional argument is placed after the remaining arguments, it too will be deemed remaining:
foo@bar:/home/dev/$ ./compiler foo.cpp bar.cpp baz.cpp -o main
5 arguments provided
foo.cpp
bar.cpp
baz.cpp
-o
main
Parent Parsers
A parser may use arguments that could be used by other parsers.
These shared arguments can be added to a parser which is then used as a "parent" for parsers which also need those arguments. One or more parent parsers may be added to a parser with .add_parents
. The positional and optional arguments in each parent is added to the child parser.
argparse::ArgumentParser surface_parser("surface", "1.0", argparse::default_arguments::none);
surface_parser.add_argument("--area")
.default_value(0)
.scan<'i', int>();
argparse::ArgumentParser floor_parser("floor");
floor_parser.add_argument("tile_size").scan<'i', int>();
floor_parser.add_parents(surface_parser);
floor_parser.parse_args({ "./main", "--area", "200", "12" }); // --area = 200, tile_size = 12
argparse::ArgumentParser ceiling_parser("ceiling");
ceiling_parser.add_argument("--color");
ceiling_parser.add_parents(surface_parser);
ceiling_parser.parse_args({ "./main", "--color", "gray" }); // --area = 0, --color = "gray"
Changes made to parents after they are added to a parser are not reflected in any child parsers. Completely initialize parent parsers before adding them to a parser.
Each parser will have the standard set of default arguments. Disable the default arguments in parent parsers to avoid duplicate help output.
Subcommands
Many programs split up their functionality into a number of sub-commands, for example, the git
program can invoke sub-commands like git checkout
, git add
, and git commit
. Splitting up functionality this way can be a particularly good idea when a program performs several different functions which require different kinds of command-line arguments. ArgumentParser
supports the creation of such sub-commands with the add_subparser()
member function.
#include <argparse/argparse.hpp>
int main(int argc, char *argv[]) {
argparse::ArgumentParser program("git");
// git add subparser
argparse::ArgumentParser add_command("add");
add_command.add_description("Add file contents to the index");
add_command.add_argument("files")
.help("Files to add content from. Fileglobs (e.g. *.c) can be given to add all matching files.")
.remaining();
// git commit subparser
argparse::ArgumentParser commit_command("commit");
commit_command.add_description("Record changes to the repository");
commit_command.add_argument("-a", "--all")
.help("Tell the command to automatically stage files that have been modified and deleted.")
.default_value(false)
.implicit_value(true);
commit_command.add_argument("-m", "--message")
.help("Use the given <msg> as the commit message.");
// git cat-file subparser
argparse::ArgumentParser catfile_command("cat-file");
catfile_command.add_description("Provide content or type and size information for repository objects");
catfile_command.add_argument("-t")
.help("Instead of the content, show the object type identified by <object>.");
catfile_command.add_argument("-p")
.help("Pretty-print the contents of <object> based on its type.");
// git submodule subparser
argparse::ArgumentParser submodule_command("submodule");
submodule_command.add_description("Initialize, update or inspect submodules");
argparse::ArgumentParser submodule_update_command("update");
submodule_update_command.add_description("Update the registered submodules to match what the superproject expects");
submodule_update_command.add_argument("--init")
.default_value(false)
.implicit_value(true);
submodule_update_command.add_argument("--recursive")
.default_value(false)
.implicit_value(true);
submodule_command.add_subparser(submodule_update_command);
program.add_subparser(add_command);
program.add_subparser(commit_command);
program.add_subparser(catfile_command);
program.add_subparser(submodule_command);
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
return 1;
}
// Use arguments
}
foo@bar:/home/dev/$ ./git --help
Usage: git [-h] {add,cat-file,commit,submodule}
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
Subcommands:
add Add file contents to the index
cat-file Provide content or type and size information for repository objects
commit Record changes to the repository
submodule Initialize, update or inspect submodules
foo@bar:/home/dev/$ ./git add --help
Usage: add [-h] files
Add file contents to the index
Positional arguments:
files Files to add content from. Fileglobs (e.g. *.c) can be given to add all matching files.
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
foo@bar:/home/dev/$ ./git commit --help
Usage: commit [-h] [--all] [--message VAR]
Record changes to the repository
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
-a, --all Tell the command to automatically stage files that have been modified and deleted.
-m, --message Use the given <msg> as the commit message.
foo@bar:/home/dev/$ ./git submodule --help
Usage: submodule [-h] {update}
Initialize, update or inspect submodules
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
Subcommands:
update Update the registered submodules to match what the superproject expects
When a help message is requested from a subparser, only the help for that particular parser will be printed. The help message will not include parent parser or sibling parser messages.
Additionally, every parser has the .is_subcommand_used("<command_name>")
and .is_subcommand_used(subparser)
member functions to check if a subcommand was used.
Sometimes there may be a need to hide part of the subcommands from the user
by suppressing information about them in an help message. To do this,
ArgumentParser
contains the method .set_suppress(bool suppress)
:
argparse::ArgumentParser program("test");
argparse::ArgumentParser hidden_cmd("hidden");
hidden_cmd.add_argument("files").remaining();
hidden_cmd.set_suppress(true);
program.add_subparser(hidden_cmd);
foo@bar:/home/dev/$ ./main -h
Usage: test [--help] [--version] {}
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
foo@bar:/home/dev/$ ./main hidden -h
Usage: hidden [--help] [--version] files
Positional arguments:
files [nargs: 0 or more]
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
Getting Argument and Subparser Instances
Argument
and ArgumentParser
instances added to an ArgumentParser
can be retrieved with .at<T>()
. The default return type is Argument
.
argparse::ArgumentParser program("test");
program.add_argument("--dir");
program.at("--dir").default_value(std::string("/home/user"));
program.add_subparser(argparse::ArgumentParser{"walk"});
program.at<argparse::ArgumentParser>("walk").add_argument("depth");
Parse Known Args
Sometimes a program may only parse a few of the command-line arguments, passing the remaining arguments on to another script or program. In these cases, the parse_known_args()
function can be useful. It works much like parse_args()
except that it does not produce an error when extra arguments are present. Instead, it returns a list of remaining argument strings.
#include <argparse/argparse.hpp>
#include <cassert>
int main(int argc, char *argv[]) {
argparse::ArgumentParser program("test");
program.add_argument("--foo").implicit_value(true).default_value(false);
program.add_argument("bar");
auto unknown_args =
program.parse_known_args({"test", "--foo", "--badger", "BAR", "spam"});
assert(program.get<bool>("--foo") == true);
assert(program.get<std::string>("bar") == std::string{"BAR"});
assert((unknown_args == std::vector<std::string>{"--badger", "spam"}));
}
Hidden argument and alias
It is sometimes desirable to offer an alias for an argument, but without it appearing it in the usage. For example, to phase out a deprecated wording of an argument while not breaking backwards compatible. This can be done with the ``ArgumentParser::add_hidden_alias_for()` method.
argparse::ArgumentParser program("test");
auto &arg = program.add_argument("--suppress").flag();
program.add_hidden_alias_for(arg, "--supress"); // old misspelled alias
The Argument::hidden()
method can also be used to prevent a (generally
optional) argument from appearing in the usage or help.
argparse::ArgumentParser program("test");
program.add_argument("--non-documented").flag().hidden();
This can also be used on positional arguments, but in that later case it only makes sense in practice for the last ones.
ArgumentParser in bool Context
An ArgumentParser
is false
until it (or one of its subparsers) have extracted
known value(s) with .parse_args
or .parse_known_args
. When using .parse_known_args
,
unknown arguments will not make a parser true
.
Custom Prefix Characters
Most command-line options will use -
as the prefix, e.g. -f/--foo
. Parsers that need to support different or additional prefix characters, e.g. for options like +f
or /foo
, may specify them using the set_prefix_chars()
.
The default prefix character is -
.
#include <argparse/argparse.hpp>
#include <cassert>
int main(int argc, char *argv[]) {
argparse::ArgumentParser program("test");
program.set_prefix_chars("-+/");
program.add_argument("+f");
program.add_argument("--bar");
program.add_argument("/foo");
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
return 1;
}
if (program.is_used("+f")) {
std::cout << "+f : " << program.get("+f") << "\n";
}
if (program.is_used("--bar")) {
std::cout << "--bar : " << program.get("--bar") << "\n";
}
if (program.is_used("/foo")) {
std::cout << "/foo : " << program.get("/foo") << "\n";
}
}
foo@bar:/home/dev/$ ./main +f 5 --bar 3.14f /foo "Hello"
+f : 5
--bar : 3.14f
/foo : Hello
Custom Assignment Characters
In addition to prefix characters, custom 'assign' characters can be set. This setting is used to allow invocations like ./test --foo=Foo /B:Bar
.
The default assign character is =
.
#include <argparse/argparse.hpp>
#include <cassert>
int main(int argc, char *argv[]) {
argparse::ArgumentParser program("test");
program.set_prefix_chars("-+/");
program.set_assign_chars("=:");
program.add_argument("--foo");
program.add_argument("/B");
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
return 1;
}
if (program.is_used("--foo")) {
std::cout << "--foo : " << program.get("--foo") << "\n";
}
if (program.is_used("/B")) {
std::cout << "/B : " << program.get("/B") << "\n";
}
}
foo@bar:/home/dev/$ ./main --foo=Foo /B:Bar
--foo : Foo
/B : Bar
Further Examples
Construct a JSON object from a filename argument
argparse::ArgumentParser program("json_test");
program.add_argument("config")
.action([](const std::string& value) {
// read a JSON file
std::ifstream stream(value);
nlohmann::json config_json;
stream >> config_json;
return config_json;
});
try {
program.parse_args({"./test", "config.json"});
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
nlohmann::json config = program.get<nlohmann::json>("config");
Positional Arguments with Compound Toggle Arguments
argparse::ArgumentParser program("test");
program.add_argument("numbers")
.nargs(3)
.scan<'i', int>();
program.add_argument("-a")
.default_value(false)
.implicit_value(true);
program.add_argument("-b")
.default_value(false)
.implicit_value(true);
program.add_argument("-c")
.nargs(2)
.scan<'g', float>();
program.add_argument("--files")
.nargs(3);
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto numbers = program.get<std::vector<int>>("numbers"); // {1, 2, 3}
auto a = program.get<bool>("-a"); // true
auto b = program.get<bool>("-b"); // true
auto c = program.get<std::vector<float>>("-c"); // {3.14f, 2.718f}
auto files = program.get<std::vector<std::string>>("--files"); // {"a.txt", "b.txt", "c.txt"}
/// Some code that prints parsed arguments
foo@bar:/home/dev/$ ./main 1 2 3 -abc 3.14 2.718 --files a.txt b.txt c.txt
numbers = {1, 2, 3}
a = true
b = true
c = {3.14, 2.718}
files = {"a.txt", "b.txt", "c.txt"}
Restricting the set of values for an argument
argparse::ArgumentParser program("test");
program.add_argument("input")
.default_value(std::string{"baz"})
.choices("foo", "bar", "baz");
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto input = program.get("input");
std::cout << input << std::endl;
foo@bar:/home/dev/$ ./main fex
Invalid argument "fex" - allowed options: {foo, bar, baz}
Using choices also works with integer types, e.g.,
argparse::ArgumentParser program("test");
program.add_argument("input")
.default_value(0)
.choices(0, 1, 2, 3, 4, 5);
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
std::exit(1);
}
auto input = program.get("input");
std::cout << input << std::endl;
foo@bar:/home/dev/$ ./main 6
Invalid argument "6" - allowed options: {0, 1, 2, 3, 4, 5}
Using option=value
syntax
#include "argparse.hpp"
#include <cassert>
int main(int argc, char *argv[]) {
argparse::ArgumentParser program("test");
program.add_argument("--foo").implicit_value(true).default_value(false);
program.add_argument("--bar");
try {
program.parse_args(argc, argv);
}
catch (const std::exception& err) {
std::cerr << err.what() << std::endl;
std::cerr << program;
return 1;
}
if (program.is_used("--foo")) {
std::cout << "--foo: " << std::boolalpha << program.get<bool>("--foo") << "\n";
}
if (program.is_used("--bar")) {
std::cout << "--bar: " << program.get("--bar") << "\n";
}
}
foo@bar:/home/dev/$ ./test --bar=BAR --foo
--foo: true
--bar: BAR
Advanced usage formatting
By default usage is reported on a single line.
The ArgumentParser::set_usage_max_line_width(width)
method can be used
to display the usage() on multiple lines, by defining the maximum line width.
It can be combined with a call to ArgumentParser::set_usage_break_on_mutex()
to ask grouped mutually exclusive arguments to be displayed on a separate line.
ArgumentParser::add_usage_newline()
can also be used to force the next
argument to be displayed on a new line in the usage output.
The following snippet
argparse::ArgumentParser program("program");
program.set_usage_max_line_width(80);
program.set_usage_break_on_mutex();
program.add_argument("--quite-long-option-name").flag();
auto &group = program.add_mutually_exclusive_group();
group.add_argument("-a").flag();
group.add_argument("-b").flag();
program.add_argument("-c").flag();
program.add_argument("--another-one").flag();
program.add_argument("-d").flag();
program.add_argument("--yet-another-long-one").flag();
program.add_argument("--will-go-on-new-line").flag();
program.add_usage_newline();
program.add_argument("--new-line").flag();
std::cout << program.usage() << std::endl;
will display:
Usage: program [--help] [--version] [--quite-long-option-name]
[[-a]|[-b]]
[-c] [--another-one] [-d] [--yet-another-long-one]
[--will-go-on-new-line]
[--new-line]
Furthermore arguments can be separated into several groups by calling
ArgumentParser::add_group(group_name)
. Only optional arguments should
be specified after the first call to add_group().
argparse::ArgumentParser program("program");
program.set_usage_max_line_width(80);
program.add_argument("-a").flag().help("help_a");
program.add_group("Advanced options");
program.add_argument("-b").flag().help("help_b");
will display:
Usage: program [--help] [--version] [-a]
Advanced options:
[-b]
Developer Notes
Copying and Moving
argparse::ArgumentParser
is intended to be used in a single function - setup everything and parse arguments in one place. Attempting to move or copy invalidates internal references (issue #260). Thus, starting with v3.0, argparse::ArgumentParser
copy and move constructors are marked as delete
.
CMake Integration
Use the latest argparse in your CMake project without copying any content.
cmake_minimum_required(VERSION 3.14)
PROJECT(myproject)
# fetch latest argparse
include(FetchContent)
FetchContent_Declare(
argparse
GIT_REPOSITORY https://github.com/p-ranav/argparse.git
)
FetchContent_MakeAvailable(argparse)
add_executable(myproject main.cpp)
target_link_libraries(myproject argparse)
Bazel Integration
Add an http_archive
in WORKSPACE.bazel, for example
http_archive(
name = "argparse",
sha256 = "674e724c2702f0bfef1619161815257a407e1babce30d908327729fba6ce4124",
strip_prefix = "argparse-3.1",
url = "https://github.com/p-ranav/argparse/archive/refs/tags/v3.1.zip",
)
Building, Installing, and Testing
# Clone the repository
git clone https://github.com/p-ranav/argparse
cd argparse
# Build the tests
mkdir build
cd build
cmake -DARGPARSE_BUILD_SAMPLES=on -DARGPARSE_BUILD_TESTS=on ..
make
# Run tests
./test/tests
# Install the library
sudo make install
Supported Toolchains
Compiler | Standard Library | Test Environment |
---|---|---|
GCC >= 8.3.0 | libstdc++ | Ubuntu 18.04 |
Clang >= 7.0.0 | libc++ | Xcode 10.2 |
MSVC >= 16.8 | Microsoft STL | Visual Studio 2019 |
Contributing
Contributions are welcome, have a look at the CONTRIBUTING.md document for more information.
License
The project is available under the MIT license.
More Resourcesto explore the angular.
mail [email protected] to add your project or resources here 🔥.
- 1Qt | Tools for Each Stage of Software Development Lifecycle
https://www.qt.io
All the essential Qt tools for all stages of Software Development Lifecycle: planning, design, development, testing, and deployment.
- 2Verovio
https://www.verovio.org
Music notation engraving library for MEI with MusicXML and Humdrum support and various toolkits (JavaScript, Python)
- 3Amplitude Audio SDK
https://amplitudeaudiosdk.com
A full-featured and cross-platform audio engine designed with the needs of games in mind.
- 4ISO C++ Standards Committee
https://github.com/cplusplus
ISO C++ Standards Committee has 30 repositories available. Follow their code on GitHub.
- 5Public development project of the LAMMPS MD software package
https://github.com/lammps/lammps
Public development project of the LAMMPS MD software package - GitHub - lammps/lammps: Public development project of the LAMMPS MD software package
- 6Small strings compression library
https://github.com/antirez/smaz
Small strings compression library. Contribute to antirez/smaz development by creating an account on GitHub.
- 7Fast, orthogonal, open multi-methods. Solve the Expression Problem in C++17.
https://github.com/jll63/yomm2
Fast, orthogonal, open multi-methods. Solve the Expression Problem in C++17. - jll63/yomm2
- 8simple neural network library in ANSI C
https://github.com/codeplea/genann
simple neural network library in ANSI C. Contribute to codeplea/genann development by creating an account on GitHub.
- 9Public/backup repository of the GROMACS molecular simulation toolkit. Please do not mine the metadata blindly; we use https://gitlab.com/gromacs/gromacs for code review and issue tracking.
https://github.com/gromacs/gromacs
Public/backup repository of the GROMACS molecular simulation toolkit. Please do not mine the metadata blindly; we use https://gitlab.com/gromacs/gromacs for code review and issue tracking. - gromac...
- 10A small self-contained alternative to readline and libedit that supports UTF-8 and Windows and is BSD licensed.
https://github.com/arangodb/linenoise-ng
A small self-contained alternative to readline and libedit that supports UTF-8 and Windows and is BSD licensed. - arangodb/linenoise-ng
- 11KFR | Fast, modern C++ DSP framework
https://www.kfrlib.com/
KFR | Fast, modern C++ DSP framework, DFT/FFT, Audio resampling, FIR, IIR and Biquad filters, Filter design, Tensors, Full vectorization
- 12LibU is a multiplatform utility library written in C, with APIs for handling memory allocation, networking and URI parsing, string manipulation, debugging, and logging in a very compact way, plus many other miscellaneous tasks
https://github.com/koanlogic/libu
LibU is a multiplatform utility library written in C, with APIs for handling memory allocation, networking and URI parsing, string manipulation, debugging, and logging in a very compact way, plus m...
- 13A header-only and easy to use Ini file parser for C++.
https://github.com/Rookfighter/inifile-cpp
A header-only and easy to use Ini file parser for C++. - Rookfighter/inifile-cpp
- 14libTorrent BitTorrent library
https://github.com/rakshasa/libtorrent
libTorrent BitTorrent library. Contribute to rakshasa/libtorrent development by creating an account on GitHub.
- 15SimplE Lossless Audio
https://github.com/sahaRatul/sela
SimplE Lossless Audio. Contribute to sahaRatul/sela development by creating an account on GitHub.
- 16Boost.org
https://github.com/boostorg
Boost provides free peer-reviewed portable C++ source libraries. - Boost.org
- 17The Official MongoDB driver for C language
https://github.com/mongodb/mongo-c-driver
The Official MongoDB driver for C language. Contribute to mongodb/mongo-c-driver development by creating an account on GitHub.
- 18The AI-native database built for LLM applications, providing incredibly fast hybrid search of dense vector, sparse vector, tensor (multi-vector), and full-text
https://github.com/infiniflow/infinity
The AI-native database built for LLM applications, providing incredibly fast hybrid search of dense vector, sparse vector, tensor (multi-vector), and full-text - infiniflow/infinity
- 19Simple Unit Testing for C
https://github.com/ThrowTheSwitch/Unity
Simple Unit Testing for C. Contribute to ThrowTheSwitch/Unity development by creating an account on GitHub.
- 20Basic Development Environment - a set of foundational C++ libraries used at Bloomberg.
https://github.com/bloomberg/bde
Basic Development Environment - a set of foundational C++ libraries used at Bloomberg. - bloomberg/bde
- 21C++14 evented IO libraries for high performance networking and media based applications
https://github.com/sourcey/libsourcey
C++14 evented IO libraries for high performance networking and media based applications - sourcey/libsourcey
- 22Asio C++ Library
https://github.com/chriskohlhoff/asio/
Asio C++ Library. Contribute to chriskohlhoff/asio development by creating an account on GitHub.
- 23A readline and libedit replacement that supports UTF-8, syntax highlighting, hints and Windows and is BSD licensed.
https://github.com/AmokHuginnsson/replxx
A readline and libedit replacement that supports UTF-8, syntax highlighting, hints and Windows and is BSD licensed. - AmokHuginnsson/replxx
- 24A lightweight header-only library for using Keras (TensorFlow) models in C++.
https://github.com/Dobiasd/frugally-deep
A lightweight header-only library for using Keras (TensorFlow) models in C++. - Dobiasd/frugally-deep
- 25A collection of std-like single-header C++ libraries
https://github.com/iboB/itlib
A collection of std-like single-header C++ libraries - iboB/itlib
- 26C++11 port of docopt
https://github.com/docopt/docopt.cpp
C++11 port of docopt. Contribute to docopt/docopt.cpp development by creating an account on GitHub.
- 27🎁 A glib-like multi-platform c library
https://github.com/tboox/tbox
🎁 A glib-like multi-platform c library. Contribute to tboox/tbox development by creating an account on GitHub.
- 28Audio decoding libraries for C/C++, each in a single source file.
https://github.com/mackron/dr_libs
Audio decoding libraries for C/C++, each in a single source file. - mackron/dr_libs
- 29Minimalistic MP3 decoder single header library
https://github.com/lieff/minimp3
Minimalistic MP3 decoder single header library. Contribute to lieff/minimp3 development by creating an account on GitHub.
- 30C library for cross-platform real-time audio input and output
https://github.com/andrewrk/libsoundio
C library for cross-platform real-time audio input and output - andrewrk/libsoundio
- 31header only, dependency-free deep learning framework in C++14
https://github.com/tiny-dnn/tiny-dnn
header only, dependency-free deep learning framework in C++14 - tiny-dnn/tiny-dnn
- 32Polycode is a cross-platform framework for creative code.
https://github.com/ivansafrin/Polycode
Polycode is a cross-platform framework for creative code. - ivansafrin/Polycode
- 33A simple C++ library for reading and writing audio files.
https://github.com/adamstark/AudioFile
A simple C++ library for reading and writing audio files. - adamstark/AudioFile
- 34An Open Source Implementation of the Actor Model in C++
https://github.com/actor-framework/actor-framework
An Open Source Implementation of the Actor Model in C++ - actor-framework/actor-framework
- 35Embedded Template Library
https://github.com/ETLCPP/etl
Embedded Template Library. Contribute to ETLCPP/etl development by creating an account on GitHub.
- 36analyzing petabytes of data, scientifically.
https://root.cern.ch/
An open-source data analysis framework used by high energy physics and others.
- 37Behavior Tree Starter Kit
https://github.com/aigamedev/btsk
Behavior Tree Starter Kit. Contribute to aigamedev/btsk development by creating an account on GitHub.
- 38C++ Parallel Computing and Asynchronous Networking Framework
https://github.com/sogou/workflow
C++ Parallel Computing and Asynchronous Networking Framework - sogou/workflow
- 39Open-Source Quantum Chemistry – an electronic structure package in C++ driven by Python
https://github.com/psi4/psi4
Open-Source Quantum Chemistry – an electronic structure package in C++ driven by Python - psi4/psi4
- 40The PGM-index
https://pgm.di.unipi.it
The Piecewise Geometric Model index (PGM-index) is a data structure that enables fast point and range searches in arrays of billions of items using orders of magnitude less space than traditional indexes.
- 41Hello from Velox | Velox
https://velox-lib.io/
Description will go into a meta tag in <head />
- 42A tiny boost library in C++11.
https://github.com/idealvin/coost
A tiny boost library in C++11. Contribute to idealvin/coost development by creating an account on GitHub.
- 43Minimal Rust-inspired C++20 STL replacement
https://github.com/TheNumbat/rpp
Minimal Rust-inspired C++20 STL replacement. Contribute to TheNumbat/rpp development by creating an account on GitHub.
- 44Concurrency library for C (coroutines)
https://github.com/tidwall/neco
Concurrency library for C (coroutines). Contribute to tidwall/neco development by creating an account on GitHub.
- 45Microsoft Cognitive Toolkit (CNTK), an open source deep-learning toolkit
https://github.com/Microsoft/CNTK
Microsoft Cognitive Toolkit (CNTK), an open source deep-learning toolkit - microsoft/CNTK
- 46A toolkit for making real world machine learning and data analysis applications in C++
https://github.com/davisking/dlib
A toolkit for making real world machine learning and data analysis applications in C++ - davisking/dlib
- 47A C++ static library offering a clean and simple interface to the 7-zip shared libraries.
https://github.com/rikyoz/bit7z
A C++ static library offering a clean and simple interface to the 7-zip shared libraries. - rikyoz/bit7z
- 48Kigs framework is a C++ modular multipurpose cross platform framework.
https://github.com/Kigs-framework/kigs
Kigs framework is a C++ modular multipurpose cross platform framework. - Kigs-framework/kigs
- 49Activity Indicators for Modern C++
https://github.com/p-ranav/indicators/
Activity Indicators for Modern C++. Contribute to p-ranav/indicators development by creating an account on GitHub.
- 50Open multi-methods for C++11
https://github.com/jll63/yomm11
Open multi-methods for C++11. Contribute to jll63/yomm11 development by creating an account on GitHub.
- 51A fast and flexible c++ template class for tree data structures
https://github.com/erikerlandson/st_tree
A fast and flexible c++ template class for tree data structures - erikerlandson/st_tree
- 52The most over-engineered C++ assertion library
https://github.com/jeremy-rifkin/libassert
The most over-engineered C++ assertion library. Contribute to jeremy-rifkin/libassert development by creating an account on GitHub.
- 53A powerful and cross-platform audio engine, optimized for games.
https://github.com/SparkyStudios/AmplitudeAudioSDK
A powerful and cross-platform audio engine, optimized for games. - SparkyStudios/AmplitudeAudioSDK
- 54Audio playback and capture library written in C, in a single source file.
https://github.com/mackron/miniaudio
Audio playback and capture library written in C, in a single source file. - mackron/miniaudio
- 55Boost.org asio module
https://github.com/boostorg/asio
Boost.org asio module. Contribute to boostorg/asio development by creating an account on GitHub.
- 56Free, easy, portable audio engine for games
https://github.com/jarikomppa/soloud
Free, easy, portable audio engine for games. Contribute to jarikomppa/soloud development by creating an account on GitHub.
- 57The project alpaka has moved to https://github.com/alpaka-group/alpaka
https://github.com/ComputationalRadiationPhysics/alpaka
The project alpaka has moved to https://github.com/alpaka-group/alpaka - ComputationalRadiationPhysics/alpaka
- 58BitTorrent DHT library
https://github.com/jech/dht
BitTorrent DHT library. Contribute to jech/dht development by creating an account on GitHub.
- 59An in-process SQL OLAP database management system
https://duckdb.org/
DuckDB is an in-process SQL OLAP database management system. Simple, feature-rich, fast & open source.
- 60Qt
https://github.com/qt
Official mirror of the qt-project.org Git repositories - Qt
- 61OpenCL - The Open Standard for Parallel Programming of Heterogeneous Systems
https://www.khronos.org/opencl/
OpenCL™ (Open Computing Language) is an open, royalty-free standard for cross-platform, parallel programming of diverse accelerators found in supercomputers, cloud servers, personal computers, mobile devices and embedded platforms. OpenCL greatly improves the speed and responsiveness of a wide spectrum of applications in numerous market categories including professional creative tools,
- 62Library and command line tool to detect SHA-1 collision in a file
https://github.com/cr-marcstevens/sha1collisiondetection
Library and command line tool to detect SHA-1 collision in a file - cr-marcstevens/sha1collisiondetection
- 63Concurrent data structures in C++
https://github.com/preshing/junction
Concurrent data structures in C++. Contribute to preshing/junction development by creating an account on GitHub.
- 64EASTL stands for Electronic Arts Standard Template Library. It is an extensive and robust implementation that has an emphasis on high performance.
https://github.com/electronicarts/EASTL
EASTL stands for Electronic Arts Standard Template Library. It is an extensive and robust implementation that has an emphasis on high performance. - electronicarts/EASTL
- 65【A common used C++ DAG framework】 一个通用的、无三方依赖的、跨平台的、收录于awesome-cpp的、基于流图的并行计算框架。欢迎star & fork & 交流
https://github.com/ChunelFeng/CGraph
【A common used C++ DAG framework】 一个通用的、无三方依赖的、跨平台的、收录于awesome-cpp的、基于流图的并行计算框架。欢迎star & fork & 交流 - ChunelFeng/CGraph
- 66Industry-standard navigation-mesh toolset for games
https://github.com/recastnavigation/recastnavigation
Industry-standard navigation-mesh toolset for games - recastnavigation/recastnavigation
- 67C++20 Microservice Bootstrapping Framework
https://github.com/volt-software/ichor
C++20 Microservice Bootstrapping Framework. Contribute to volt-software/Ichor development by creating an account on GitHub.
- 68LZFSE compression library and command line tool
https://github.com/lzfse/lzfse
LZFSE compression library and command line tool. Contribute to lzfse/lzfse development by creating an account on GitHub.
- 69Boost.org program_options module
https://github.com/boostorg/program_options
Boost.org program_options module. Contribute to boostorg/program_options development by creating an account on GitHub.
- 70Argument Parser for Modern C++
https://github.com/p-ranav/argparse
Argument Parser for Modern C++. Contribute to p-ranav/argparse development by creating an account on GitHub.
- 71A curses library for environments that don't fit the termcap/terminfo model.
https://github.com/wmcbrine/PDCurses
A curses library for environments that don't fit the termcap/terminfo model. - wmcbrine/PDCurses
- 72Easy and efficient audio synthesis in C++
https://github.com/TonicAudio/Tonic
Easy and efficient audio synthesis in C++. Contribute to TonicAudio/Tonic development by creating an account on GitHub.
- 73The Massively Parallel Quantum Chemistry program, MPQC, computes properties of atoms and molecules from first principles using the time independent Schrödinger equation.
https://github.com/ValeevGroup/mpqc
The Massively Parallel Quantum Chemistry program, MPQC, computes properties of atoms and molecules from first principles using the time independent Schrödinger equation. - ValeevGroup/mpqc
- 74A library for audio and music analysis, feature extraction.
https://github.com/libAudioFlux/audioFlux
A library for audio and music analysis, feature extraction. - libAudioFlux/audioFlux
- 75C++ Audio and Music DSP Library
https://github.com/micknoise/Maximilian
C++ Audio and Music DSP Library. Contribute to micknoise/Maximilian development by creating an account on GitHub.
- 76Thin, unified, C++-flavored wrappers for the CUDA APIs
https://github.com/eyalroz/cuda-api-wrappers
Thin, unified, C++-flavored wrappers for the CUDA APIs - eyalroz/cuda-api-wrappers
- 77a unified framework for modeling chemically reactive systems
https://github.com/reaktoro/reaktoro
a unified framework for modeling chemically reactive systems - reaktoro/reaktoro
- 78ImTui: Immediate Mode Text-based User Interface C++ Library
https://github.com/ggerganov/imtui
ImTui: Immediate Mode Text-based User Interface C++ Library - ggerganov/imtui
- 79Library for writing text-based user interfaces
https://github.com/nsf/termbox
Library for writing text-based user interfaces. Contribute to nsf/termbox development by creating an account on GitHub.
- 80A simple to use, composable, command line parser for C++ 11 and beyond
https://github.com/bfgroup/Lyra
A simple to use, composable, command line parser for C++ 11 and beyond - bfgroup/Lyra
- 81MariadeAnton/MiLi
https://github.com/MariadeAnton/MiLi
Contribute to MariadeAnton/MiLi development by creating an account on GitHub.
- 82Distributed machine learning platform
https://github.com/Samsung/veles
Distributed machine learning platform. Contribute to Samsung/veles development by creating an account on GitHub.
- 83The project alpaka has moved to https://github.com/alpaka-group/cupla
https://github.com/ComputationalRadiationPhysics/cupla
The project alpaka has moved to https://github.com/alpaka-group/cupla - GitHub - ComputationalRadiationPhysics/cupla: The project alpaka has moved to https://github.com/alpaka-group/cupla
- 84Open Source Document-oriented DB
https://reindexer.io/
Free NoSQL in-memory database with web interface
- 85A general-purpose lightweight C++ graph library
https://github.com/bobluppes/graaf
A general-purpose lightweight C++ graph library. Contribute to bobluppes/graaf development by creating an account on GitHub.
- 86A C++ vectorized database acceleration library aimed to optimizing query engines and data processing systems.
https://github.com/facebookincubator/velox
A C++ vectorized database acceleration library aimed to optimizing query engines and data processing systems. - facebookincubator/velox
- 87Cross-platform asynchronous I/O
https://github.com/libuv/libuv
Cross-platform asynchronous I/O. Contribute to libuv/libuv development by creating an account on GitHub.
- 88an efficient feature complete C++ bittorrent implementation
https://github.com/arvidn/libtorrent
an efficient feature complete C++ bittorrent implementation - arvidn/libtorrent
- 89A small self-contained alternative to readline and libedit
https://github.com/antirez/linenoise
A small self-contained alternative to readline and libedit - antirez/linenoise
- 90Simple and yet powerful cross-platform C library providing data structures, algorithms and much more
https://github.com/kala13x/libxutils
Simple and yet powerful cross-platform C library providing data structures, algorithms and much more - kala13x/libxutils
- 91Lightweight C++ command line option parser
https://github.com/jarro2783/cxxopts
Lightweight C++ command line option parser. Contribute to jarro2783/cxxopts development by creating an account on GitHub.
- 92uTorrent Transport Protocol library
https://github.com/bittorrent/libutp
uTorrent Transport Protocol library. Contribute to bittorrent/libutp development by creating an account on GitHub.
- 93A better and stronger spiritual successor to BZip2.
https://github.com/kspalaiologos/bzip3
A better and stronger spiritual successor to BZip2. - kspalaiologos/bzip3
- 94Abseil Common Libraries (C++)
https://github.com/abseil/abseil-cpp
Abseil Common Libraries (C++). Contribute to abseil/abseil-cpp development by creating an account on GitHub.
- 95Brotli compression format
https://github.com/google/brotli
Brotli compression format. Contribute to google/brotli development by creating an account on GitHub.
- 96NI Media is a C++ library for reading and writing audio streams.
https://github.com/NativeInstruments/ni-media
NI Media is a C++ library for reading and writing audio streams. - NativeInstruments/ni-media
- 97Multiresolution Adaptive Numerical Environment for Scientific Simulation
https://github.com/m-a-d-n-e-s-s/madness
Multiresolution Adaptive Numerical Environment for Scientific Simulation - m-a-d-n-e-s-s/madness
- 98Zstandard - Fast real-time compression algorithm
https://github.com/facebook/zstd
Zstandard - Fast real-time compression algorithm. Contribute to facebook/zstd development by creating an account on GitHub.
- 99Multi-format archive and compression library
https://github.com/libarchive/libarchive
Multi-format archive and compression library. Contribute to libarchive/libarchive development by creating an account on GitHub.
- 100Structural variant detection and association testing
https://github.com/zeeev/wham
Structural variant detection and association testing - zeeev/wham
- 101Thread-safe container for sharing data between threads
https://github.com/andreiavrammsd/cpp-channel
Thread-safe container for sharing data between threads - andreiavrammsd/cpp-channel
- 102data compression library for embedded/real-time systems
https://github.com/atomicobject/heatshrink
data compression library for embedded/real-time systems - atomicobject/heatshrink
- 103The libdispatch Project, (a.k.a. Grand Central Dispatch), for concurrency on multicore hardware
https://github.com/apple/swift-corelibs-libdispatch
The libdispatch Project, (a.k.a. Grand Central Dispatch), for concurrency on multicore hardware - apple/swift-corelibs-libdispatch
- 104Async++ concurrency framework for C++11
https://github.com/Amanieu/asyncplusplus
Async++ concurrency framework for C++11. Contribute to Amanieu/asyncplusplus development by creating an account on GitHub.
- 105THIS REPOSITORY HAS MOVED TO github.com/nvidia/cub, WHICH IS AUTOMATICALLY MIRRORED HERE.
https://github.com/NVlabs/cub
THIS REPOSITORY HAS MOVED TO github.com/nvidia/cub, WHICH IS AUTOMATICALLY MIRRORED HERE. - NVlabs/cub
- 106OpenCL based GPU accelerated SPH fluid simulation library
https://github.com/libclsph/libclsph
OpenCL based GPU accelerated SPH fluid simulation library - libclsph/libclsph
- 107High performance server-side application framework
https://github.com/scylladb/seastar
High performance server-side application framework - scylladb/seastar
- 108Fast lossless data compression in C++
https://github.com/flanglet/kanzi-cpp
Fast lossless data compression in C++. Contribute to flanglet/kanzi-cpp development by creating an account on GitHub.
- 109miniz: Single C source file zlib-replacement library, originally from code.google.com/p/miniz
https://github.com/richgel999/miniz
miniz: Single C source file zlib-replacement library, originally from code.google.com/p/miniz - richgel999/miniz
- 110A C++ GPU Computing Library for OpenCL
https://github.com/boostorg/compute
A C++ GPU Computing Library for OpenCL. Contribute to boostorg/compute development by creating an account on GitHub.
- 111CLI11 is a command line parser for C++11 and beyond that provides a rich feature set with a simple and intuitive interface.
https://github.com/CLIUtils/CLI11
CLI11 is a command line parser for C++11 and beyond that provides a rich feature set with a simple and intuitive interface. - CLIUtils/CLI11
- 112Fork of the popular zip manipulation library found in the zlib distribution.
https://github.com/zlib-ng/minizip-ng
Fork of the popular zip manipulation library found in the zlib distribution. - zlib-ng/minizip-ng
- 113A text-based widget toolkit
https://github.com/gansm/finalcut
A text-based widget toolkit. Contribute to gansm/finalcut development by creating an account on GitHub.
- 114Argh! A minimalist argument handler.
https://github.com/adishavit/argh
Argh! A minimalist argument handler. Contribute to adishavit/argh development by creating an account on GitHub.
- 115C++17 Terminal User Interface(TUI) Library.
https://github.com/a-n-t-h-o-n-y/TermOx
C++17 Terminal User Interface(TUI) Library. Contribute to a-n-t-h-o-n-y/TermOx development by creating an account on GitHub.
- 116A fast, memory efficient hash map for C++
https://github.com/greg7mdp/sparsepp
A fast, memory efficient hash map for C++. Contribute to greg7mdp/sparsepp development by creating an account on GitHub.
- 117oneAPI Deep Neural Network Library (oneDNN)
https://github.com/oneapi-src/oneDNN
oneAPI Deep Neural Network Library (oneDNN). Contribute to oneapi-src/oneDNN development by creating an account on GitHub.
- 118New generation entropy codecs : Finite State Entropy and Huff0
https://github.com/Cyan4973/FiniteStateEntropy
New generation entropy codecs : Finite State Entropy and Huff0 - Cyan4973/FiniteStateEntropy
- 119Convenient, high-performance RGB color and position control for console output
https://github.com/s9w/oof
Convenient, high-performance RGB color and position control for console output - s9w/oof
- 120Extremely Fast Compression algorithm
https://github.com/lz4/lz4
Extremely Fast Compression algorithm. Contribute to lz4/lz4 development by creating an account on GitHub.
- 121Sane C++ Libraries
https://github.com/Pagghiu/SaneCppLibraries
Sane C++ Libraries. Contribute to Pagghiu/SaneCppLibraries development by creating an account on GitHub.
- 122Header-only, event based, tiny and easy to use libuv wrapper in modern C++ - now available as also shared/static library!
https://github.com/skypjack/uvw
Header-only, event based, tiny and easy to use libuv wrapper in modern C++ - now available as also shared/static library! - skypjack/uvw
- 123Bolt is a C++ template library optimized for GPUs. Bolt provides high-performance library implementations for common algorithms such as scan, reduce, transform, and sort.
https://github.com/HSA-Libraries/Bolt
Bolt is a C++ template library optimized for GPUs. Bolt provides high-performance library implementations for common algorithms such as scan, reduce, transform, and sort. - HSA-Libraries/Bolt
- 124Framework for Enterprise Application Development in c++, HTTP1/HTTP2/HTTP3 compliant, Supports multiple server backends
https://github.com/sumeetchhetri/ffead-cpp
Framework for Enterprise Application Development in c++, HTTP1/HTTP2/HTTP3 compliant, Supports multiple server backends - GitHub - sumeetchhetri/ffead-cpp: Framework for Enterprise Application De...
- 125An Open Source Machine Learning Framework for Everyone
https://github.com/tensorflow/tensorflow
An Open Source Machine Learning Framework for Everyone - tensorflow/tensorflow
- 126The C++ Standard Library for Parallelism and Concurrency
https://github.com/STEllAR-GROUP/hpx/
The C++ Standard Library for Parallelism and Concurrency - STEllAR-GROUP/hpx
- 127ArrayFire: a general purpose GPU library.
https://github.com/arrayfire/arrayfire
ArrayFire: a general purpose GPU library. Contribute to arrayfire/arrayfire development by creating an account on GitHub.
- 128Kokkos C++ Performance Portability Programming Ecosystem: The Programming Model - Parallel Execution and Memory Abstraction
https://github.com/kokkos/kokkos
Kokkos C++ Performance Portability Programming Ecosystem: The Programming Model - Parallel Execution and Memory Abstraction - kokkos/kokkos
- 129kaldi-asr/kaldi is the official location of the Kaldi project.
https://github.com/kaldi-asr/kaldi
kaldi-asr/kaldi is the official location of the Kaldi project. - kaldi-asr/kaldi
- 130Concurrency primitives, safe memory reclamation mechanisms and non-blocking (including lock-free) data structures designed to aid in the research, design and implementation of high performance concurrent systems developed in C99+.
https://github.com/concurrencykit/ck
Concurrency primitives, safe memory reclamation mechanisms and non-blocking (including lock-free) data structures designed to aid in the research, design and implementation of high performance conc...
- 131A C++ library of Concurrent Data Structures
https://github.com/khizmax/libcds
A C++ library of Concurrent Data Structures. Contribute to khizmax/libcds development by creating an account on GitHub.
- 132Header-only C++ program options parser library
https://github.com/badaix/popl
Header-only C++ program options parser library. Contribute to badaix/popl development by creating an account on GitHub.
- 133Gzip Decompression and Random Access for Modern Multi-Core Machines
https://github.com/mxmlnkn/rapidgzip
Gzip Decompression and Random Access for Modern Multi-Core Machines - mxmlnkn/rapidgzip
- 134C++ library for writing multiplatform terminal applications
https://github.com/jupyter-xeus/cpp-terminal
C++ library for writing multiplatform terminal applications - jupyter-xeus/cpp-terminal
- 135🔥 比libevent/libuv/asio更易用的网络库。A c/c++ network library for developing TCP/UDP/SSL/HTTP/WebSocket/MQTT client/server.
https://github.com/ithewei/libhv
🔥 比libevent/libuv/asio更易用的网络库。A c/c++ network library for developing TCP/UDP/SSL/HTTP/WebSocket/MQTT client/server. - ithewei/libhv
- 136Developer-friendly Continuous Regression Testing
https://touca.io/
Touca is a continuous regression testing solution that helps software engineering teams gain confidence in their daily code changes.
- 137delta3d Open Source Engine
http://sourceforge.net/projects/delta3d/
Download delta3d Open Source Engine for free. Sorry this project is no longer being supported. This project is not currently being supported but feel free to use it as an example. delta3d is a robust simulation platform built using open standards and open source software.
- 138raftlib.io
http://raftlib.io/
Simple, easy to use stream computation library for C++.
- 139googletest/googlemock/README.md at main · google/googletest
https://github.com/google/googletest/blob/master/googlemock/README.md
GoogleTest - Google Testing and Mocking Framework. Contribute to google/googletest development by creating an account on GitHub.
- 140oneAPI DPC++ Library (oneDPL) https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/dpc-library.html
https://github.com/intel/parallelstl
oneAPI DPC++ Library (oneDPL) https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/dpc-library.html - GitHub - oneapi-src/oneDPL: oneAPI DPC++ Library (oneDPL) https://soft...
- 141Fork of the popular zip manipulation library found in the zlib distribution.
https://github.com/nmoinvaz/minizip
Fork of the popular zip manipulation library found in the zlib distribution. - zlib-ng/minizip-ng
- 142The fastest feature-rich C++11/14/17/20/23 single-header testing framework
https://github.com/onqtam/doctest
The fastest feature-rich C++11/14/17/20/23 single-header testing framework - doctest/doctest
- 143Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Scala, Go, Javascript and more
https://github.com/apache/incubator-mxnet
Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Scala, Go, Javascript and more - apache/mxnet
- 144C++React: A reactive programming library for C++11.
https://github.com/schlangster/cpp.react
C++React: A reactive programming library for C++11. - snakster/cpp.react
- 145An eventing framework for building high performance and high scalability systems in C.
https://github.com/facebook/libphenom
An eventing framework for building high performance and high scalability systems in C. - facebookarchive/libphenom
- 146Facebook AI Research's Automatic Speech Recognition Toolkit
https://github.com/facebookresearch/wav2letter/
Facebook AI Research's Automatic Speech Recognition Toolkit - GitHub - flashlight/wav2letter: Facebook AI Research's Automatic Speech Recognition Toolkit
- 147C++ library and cmdline tools for parsing and manipulating VCF files with python and zig bindings
https://github.com/ekg/vcflib
C++ library and cmdline tools for parsing and manipulating VCF files with python and zig bindings - vcflib/vcflib
- 148🎵 Music notation engraving library for MEI with MusicXML and Humdrum support and various toolkits (JavaScript, Python)
https://github.com/rism-ch/verovio
🎵 Music notation engraving library for MEI with MusicXML and Humdrum support and various toolkits (JavaScript, Python) - rism-digital/verovio
- 149A C library for reading and writing sound files containing sampled audio data.
https://github.com/erikd/libsndfile/
A C library for reading and writing sound files containing sampled audio data. - libsndfile/libsndfile
- 150JUCE is an open-source cross-platform C++ application framework for desktop and mobile applications, including VST, VST3, AU, AUv3, LV2 and AAX audio plug-ins.
https://github.com/julianstorer/JUCE
JUCE is an open-source cross-platform C++ application framework for desktop and mobile applications, including VST, VST3, AU, AUv3, LV2 and AAX audio plug-ins. - juce-framework/JUCE
- 151Chaste
http://www.cs.ox.ac.uk/chaste/
Chaste
- 152raylib
http://www.raylib.com/
raylib is a simple and easy-to-use library to enjoy videogames programming.
- 153Open Ecosystem
https://01.org/onednn
Access technologies from partnerships with the community and leaders. Everything open source at Intel. We have a lot to share and a lot to learn.
- 154oneAPI Threading Building Blocks (oneTBB)
https://www.threadingbuildingblocks.org/
oneAPI Threading Building Blocks (oneTBB). Contribute to oneapi-src/oneTBB development by creating an account on GitHub.
- 155Home - OpenMP
http://openmp.org/
yes
- 156TileDB -The Modern Database
https://tiledb.io/
TileDB is the modern data stack in a box. All data, code, and compute in a single product.
- 157PLATINUMTOTO | SITUS JUDI SLOT GACOR SERVER RUSIA AUTO MAXWIN!!!
http://cmldev.net/
PLATINUMTOTO adalah situs judi slot gacor maxwin server RUSIA, yang memberikan pengalaman berjudi slot gacor gampang menang auto maxwin!!!
- 158A fast image processing library with low memory needs.
http://www.vips.ecs.soton.ac.uk/
A fast image processing library with low memory needs. - libvips/libvips
- 159Home
http://opencv.org/
OpenCV provides a real-time optimized Computer Vision library, tools, and hardware. It also supports model execution for Machine Learning (ML) and Artificial Intelligence (AI).
- 160libjson
http://sourceforge.net/projects/libjson/
Download libjson for free. A JSON reader and writer which is super-effiecient and usually runs circles around other JSON libraries. It's highly customizable to optimize for your particular project, and very lightweight.
- 161The GTK Project - A free and open-source cross-platform widget toolkit
http://www.gtk.org/
GTK is a free and open-source cross-platform widget toolkit for creating graphical user interfaces.
- 162Magnum Engine
http://magnum.graphics
Lightweight and modular C++11/C++14 graphics middleware for games and data visualization
- 163Panda3D | Open Source Framework for 3D Rendering & Games
http://www.panda3d.org/
Panda3D is an open-source, cross-platform, completely free-to-use engine for realtime 3D games, visualizations, simulations, experiments — you name it! Its rich feature set readily tailors to your specific workflow and development needs.
- 164ICU - International Components for Unicode
http://site.icu-project.org/
News 2024-04-17: ICU 75 is now available. It updates to CLDR 45 (beta blog) locale data with new locales and various additions and corrections. C++ code now requires C++17 and is being made more robust. The CLDR MessageFormat 2.0 specification is now in technology preview, together with a
- 165gRPC
http://www.grpc.io/
A high-performance, open source universal RPC framework
- 166CrowCpp
https://crowcpp.org
A Fast and Easy to use microframework for the web.
- 167Meeting Cpp
https://www.youtube.com/user/MeetingCPP/videos
Meeting C++ is an independent platform for C++, supporting the C++ community by sharing news, blogs and events for C++. Details on the yearly Meeting C++ Conference can be found on the website https://meetingcpp.com
- 168A sort wrapper enabling both use of random-access sorting on non-random access containers, and increased performance for the sorting of large types.
https://github.com/mattreecebentley/plf_indiesort
A sort wrapper enabling both use of random-access sorting on non-random access containers, and increased performance for the sorting of large types. - mattreecebentley/plf_indiesort
- 169Open Watcom V2
https://github.com/open-watcom
Open Watcom V2 has 6 repositories available. Follow their code on GitHub.
- 170CppCon
https://www.youtube.com/user/CppCon/videos
Visit cppcon.org for details on next year's conference. CppCon sponsors have made it possible to record and freely distribute over 1000 sessions from the first CppCon in 2014 to the present. We hope you enjoy them!
- 171Protocol Buffers implementation in C
https://github.com/protobuf-c/protobuf-c
Protocol Buffers implementation in C. Contribute to protobuf-c/protobuf-c development by creating an account on GitHub.
- 172C++ GUI with Qt Playlist
https://www.youtube.com/playlist?list=PLD0D54219E5F2544D
Official Playlist for thenewboston C++ GUI with Qt tutorials!
- 173ZXing ("Zebra Crossing") barcode scanning library for Java, Android
https://github.com/zxing/zxing/
ZXing ("Zebra Crossing") barcode scanning library for Java, Android - zxing/zxing
- 174A YAML parser and emitter in C++
https://github.com/jbeder/yaml-cpp
A YAML parser and emitter in C++. Contribute to jbeder/yaml-cpp development by creating an account on GitHub.
- 175"interesting" VM in C. Let's see how this goes.
https://github.com/tekknolagi/carp
"interesting" VM in C. Let's see how this goes. Contribute to tekknolagi/carp development by creating an account on GitHub.
- 176Boost.org serialization module
https://github.com/boostorg/serialization
Boost.org serialization module. Contribute to boostorg/serialization development by creating an account on GitHub.
- 177Parsing Expression Grammar Template Library
https://github.com/taocpp/PEGTL
Parsing Expression Grammar Template Library. Contribute to taocpp/PEGTL development by creating an account on GitHub.
- 178A C++ Discord API Library for Bots - D++ - The lightweight C++ Discord API Library
https://dpp.dev
A lightweight C++ Discord API library supporting the entire Discord API, including Slash Commands, Voice/Audio, Sharding, Clustering and more!
- 179Full C++17 course
https://www.youtube.com/playlist?list=PLwhKb0RIaIS1sJkejUmWj-0lk7v_xgCuT
This playlist covers what one needs to know about coding in C++ 17. We start with a program that prints the "hello world" to screen and progressively dive in...
- 180Asio C++ Library
https://github.com/chriskohlhoff/asio/
Asio C++ Library. Contribute to chriskohlhoff/asio development by creating an account on GitHub.
- 181Single header YAML 1.0 C++11 serializer/deserializer.
https://github.com/jimmiebergmann/mini-yaml
Single header YAML 1.0 C++11 serializer/deserializer. - jimmiebergmann/mini-yaml
- 182C++ Programming Tutorials Playlist
https://www.youtube.com/playlist?list=PLAE85DE8440AA6B83
thenewboston Official Buckys C++ Programming Tutorials Playlist!
- 183Slides and other materials from CppCon 2020
https://github.com/CppCon/CppCon2020
Slides and other materials from CppCon 2020. Contribute to CppCon/CppCon2020 development by creating an account on GitHub.
- 184Eric Niebler
http://ericniebler.com/
Judge me by my C++, not my WordPress
- 185C++ Library Manager for Windows, Linux, and MacOS
https://github.com/microsoft/vcpkg
C++ Library Manager for Windows, Linux, and MacOS. Contribute to microsoft/vcpkg development by creating an account on GitHub.
- 186C++ Programming Tutorials from thenewboston
https://www.youtube.com/playlist?list=PLF541C2C1F671AEF6
These are all of my C++ programming tutorials
- 187libsigc++ implements a typesafe callback system for standard C++. It allows you to define signals and to connect those signals to any callback function, either global or a member function, regardless of whether it is static or virtual.
https://github.com/libsigcplusplus/libsigcplusplus
libsigc++ implements a typesafe callback system for standard C++. It allows you to define signals and to connect those signals to any callback function, either global or a member function, regardle...
- 188Cross-platform, Serial Port library written in C++
https://github.com/wjwwood/serial
Cross-platform, Serial Port library written in C++ - wjwwood/serial
- 189C Programming Tutorials
https://www.youtube.com/playlist?list=PL78280D6BE6F05D34
All if my C programming tutorials are right here!
- 190Bo Qian
https://www.youtube.com/user/BoQianTheProgrammer/playlists
The purpose of this channel is to teach various C++ programming topics in a short video format. You are welcomed to provide feedbacks so I can constantly improve the videos.
- 191a small C library for x86 CPU detection and feature extraction
https://github.com/anrieff/libcpuid
a small C library for x86 CPU detection and feature extraction - anrieff/libcpuid
- 192Awesome C Programming Tutorials in Hi Def [HD]
https://www.youtube.com/playlist?list=PLCB9F975ECF01953C
This is a collection of detailed C Programming Language Tutorials for Beginners and New Programmers. If you go through these tutorials you should have a fair...
- 193Catalog of C++ conferences worldwide
https://github.com/eoan-ermine/cpp-conferences
Catalog of C++ conferences worldwide. Contribute to eoan-ermine/cpp-conferences development by creating an account on GitHub.
- 194C++ package retrieval
https://github.com/pfultz2/cget
C++ package retrieval. Contribute to pfultz2/cget development by creating an account on GitHub.
- 195Slides and other materials from CppCon 2017
https://github.com/CppCon/CppCon2017
Slides and other materials from CppCon 2017. Contribute to CppCon/CppCon2017 development by creating an account on GitHub.
- 196A C++14 cheat-sheet on lvalues, rvalues, xvalues, and more
https://github.com/jeaye/value-category-cheatsheet
A C++14 cheat-sheet on lvalues, rvalues, xvalues, and more - jeaye/value-category-cheatsheet
- 197C++ Faker library for generating fake (but realistic) data.
https://github.com/cieslarmichal/faker-cxx
C++ Faker library for generating fake (but realistic) data. - cieslarmichal/faker-cxx
- 198NIH Utility Library
https://github.com/keybuk/libnih
NIH Utility Library. Contribute to keybuk/libnih development by creating an account on GitHub.
- 199Yet Another Serialization
https://github.com/niXman/yas
Yet Another Serialization. Contribute to niXman/yas development by creating an account on GitHub.
- 200A C++11 library for serialization
https://github.com/USCiLab/cereal
A C++11 library for serialization. Contribute to USCiLab/cereal development by creating an account on GitHub.
- 201A C++ header-only parser for the PLY file format. Parse .ply happily!
https://github.com/nmwsharp/happly
A C++ header-only parser for the PLY file format. Parse .ply happily! - nmwsharp/happly
- 202TinyVM is a small, fast, lightweight virtual machine written in pure ANSI C.
https://github.com/jakogut/tinyvm
TinyVM is a small, fast, lightweight virtual machine written in pure ANSI C. - jakogut/tinyvm
- 203TinyXML2 is a simple, small, efficient, C++ XML parser that can be easily integrated into other programs.
https://github.com/leethomason/tinyxml2
TinyXML2 is a simple, small, efficient, C++ XML parser that can be easily integrated into other programs. - leethomason/tinyxml2
- 204A safe and fast high-level and low-level character input/output library for bare-metal and RTOS based embedded systems with a very small binary footprint.
https://github.com/Viatorus/emio
A safe and fast high-level and low-level character input/output library for bare-metal and RTOS based embedded systems with a very small binary footprint. - Viatorus/emio
- 205Open Source H.264 Codec
https://github.com/cisco/openh264
Open Source H.264 Codec . Contribute to cisco/openh264 development by creating an account on GitHub.
- 206A header-only library for C++(0x) that allows automagic pretty-printing of any container.
https://github.com/louisdx/cxx-prettyprint
A header-only library for C++(0x) that allows automagic pretty-printing of any container. - louisdx/cxx-prettyprint
- 207gcc-poison
https://github.com/leafsr/gcc-poison
gcc-poison. Contribute to leafsr/gcc-poison development by creating an account on GitHub.
- 208Boost.org asio module
https://github.com/boostorg/asio
Boost.org asio module. Contribute to boostorg/asio development by creating an account on GitHub.
- 209Bond is a cross-platform framework for working with schematized data. It supports cross-language de/serialization and powerful generic mechanisms for efficiently manipulating data. Bond is broadly used at Microsoft in high scale services.
https://github.com/Microsoft/bond
Bond is a cross-platform framework for working with schematized data. It supports cross-language de/serialization and powerful generic mechanisms for efficiently manipulating data. Bond is broadly ...
- 210A fast, portable, simple, and free C/C++ IDE
https://github.com/Embarcadero/Dev-Cpp
A fast, portable, simple, and free C/C++ IDE. Contribute to Embarcadero/Dev-Cpp development by creating an account on GitHub.
- 211A C++ Web Framework built on top of Qt, using the simple approach of Catalyst (Perl) framework.
https://github.com/cutelyst/cutelyst
A C++ Web Framework built on top of Qt, using the simple approach of Catalyst (Perl) framework. - cutelyst/cutelyst
- 212a small protobuf implementation in C
https://github.com/protocolbuffers/upb
a small protobuf implementation in C. Contribute to protocolbuffers/upb development by creating an account on GitHub.
- 213The Evil License Manager
https://github.com/avati/libevil
The Evil License Manager. Contribute to avati/libevil development by creating an account on GitHub.
- 214Cista is a simple, high-performance, zero-copy C++ serialization & reflection library.
https://github.com/felixguendling/cista
Cista is a simple, high-performance, zero-copy C++ serialization & reflection library. - felixguendling/cista
- 215Your binary serialization library
https://github.com/fraillt/bitsery
Your binary serialization library. Contribute to fraillt/bitsery development by creating an account on GitHub.
- 216Boost.org property_tree module
https://github.com/boostorg/property_tree
Boost.org property_tree module. Contribute to boostorg/property_tree development by creating an account on GitHub.
- 217Automatically exported from code.google.com/p/vartypes
https://github.com/szi/vartypes
Automatically exported from code.google.com/p/vartypes - szi/vartypes
- 218VerbalExpressions/QtVerbalExpressions
https://github.com/VerbalExpressions/QtVerbalExpressions
Contribute to VerbalExpressions/QtVerbalExpressions development by creating an account on GitHub.
- 219collection of C/C++ programs that try to get compilers to exploit undefined behavior
https://github.com/regehr/ub-canaries
collection of C/C++ programs that try to get compilers to exploit undefined behavior - regehr/ub-canaries
- 220MessagePack implementation for C and C++ / msgpack.org[C/C++]
https://github.com/msgpack/msgpack-c
MessagePack implementation for C and C++ / msgpack.org[C/C++] - msgpack/msgpack-c
- 221:fish_cake: A new take on polymorphism
https://github.com/iboB/dynamix
:fish_cake: A new take on polymorphism. Contribute to iboB/dynamix development by creating an account on GitHub.
- 222Cap'n Proto serialization/RPC system - core tools and C++ library
https://github.com/capnproto/capnproto
Cap'n Proto serialization/RPC system - core tools and C++ library - capnproto/capnproto
- 223A C/C++ header to help move #ifdefs out of your code
https://github.com/nemequ/hedley
A C/C++ header to help move #ifdefs out of your code - nemequ/hedley
- 224A Small C Compiler
https://github.com/rui314/8cc
A Small C Compiler. Contribute to rui314/8cc development by creating an account on GitHub.
- 225Apache Xalan C
https://github.com/apache/xalan-c
Apache Xalan C. Contribute to apache/xalan-c development by creating an account on GitHub.
- 226C++ Cheat Sheets & Infographics
https://hackingcpp.com/cpp/cheat_sheets.html
Graphics and cheat sheets, each capturing one aspect of C++: algorithms/containers/STL, language basics, libraries, best practices, terminology (信息图表和备忘录).
- 227A client/server indexer for c/c++/objc[++] with integration for Emacs based on clang.
https://github.com/Andersbakken/rtags
A client/server indexer for c/c++/objc[++] with integration for Emacs based on clang. - Andersbakken/rtags
- 228Pattern-defeating quicksort.
https://github.com/orlp/pdqsort
Pattern-defeating quicksort. Contribute to orlp/pdqsort development by creating an account on GitHub.
- 229Formatted C++20 stdlib man pages (cppreference)
https://github.com/jeaye/stdman
Formatted C++20 stdlib man pages (cppreference). Contribute to jeaye/stdman development by creating an account on GitHub.
- 230Online editor and compiler
https://paiza.io/en
Paiza.IO is online editor and compiler. Java, Ruby, Python, PHP, Perl, Swift, JavaScript... You can use for learning programming, scraping web sites, or writing batch
- 231Xcode - Apple Developer
https://developer.apple.com/xcode/
Xcode includes everything you need to develop, test, and distribute apps across all Apple platforms.
- 232Vireo is a lightweight and versatile video processing library written in C++11
https://github.com/twitter/vireo/
Vireo is a lightweight and versatile video processing library written in C++11 - twitter/vireo
- 233Easy to use and fast C++ CRC library.
https://github.com/d-bahr/CRCpp
Easy to use and fast C++ CRC library. Contribute to d-bahr/CRCpp development by creating an account on GitHub.
- 234CCTZ is a C++ library for translating between absolute and civil times using the rules of a time zone.
https://github.com/google/cctz
CCTZ is a C++ library for translating between absolute and civil times using the rules of a time zone. - google/cctz
- 235Rapid fuzzy string matching in C++ using the Levenshtein Distance
https://github.com/rapidfuzz/rapidfuzz-cpp
Rapid fuzzy string matching in C++ using the Levenshtein Distance - rapidfuzz/rapidfuzz-cpp
- 236Boost.org signals2 module
https://github.com/boostorg/signals2
Boost.org signals2 module. Contribute to boostorg/signals2 development by creating an account on GitHub.
- 237Mobile robot simulator
https://github.com/rtv/Stage
Mobile robot simulator. Contribute to rtv/Stage development by creating an account on GitHub.
- 238Visual Studio Code - Code Editing. Redefined
https://code.visualstudio.com
Visual Studio Code is a code editor redefined and optimized for building and debugging modern web and cloud applications. Visual Studio Code is free and available on your favorite platform - Linux, macOS, and Windows.
- 239scanf for modern C++
https://github.com/eliaskosunen/scnlib
scanf for modern C++. Contribute to eliaskosunen/scnlib development by creating an account on GitHub.
- 240A date and time library based on the C++11/14/17 <chrono> header
https://github.com/HowardHinnant/date
A date and time library based on the C++11/14/17 <chrono> header - HowardHinnant/date
- 241universal serialization engine
https://github.com/qicosmos/iguana
universal serialization engine. Contribute to qicosmos/iguana development by creating an account on GitHub.
- 242Sorting algorithms & related tools for C++14
https://github.com/Morwenn/cpp-sort
Sorting algorithms & related tools for C++14. Contribute to Morwenn/cpp-sort development by creating an account on GitHub.
- 243The C++ REST SDK is a Microsoft project for cloud-based client-server communication in native code using a modern asynchronous C++ API design. This project aims to help C++ developers connect to and interact with services.
https://github.com/Microsoft/cpprestsdk
The C++ REST SDK is a Microsoft project for cloud-based client-server communication in native code using a modern asynchronous C++ API design. This project aims to help C++ developers connect to an...
- 244Compile and execute C "scripts" in one go!
https://github.com/ryanmjacobs/c
Compile and execute C "scripts" in one go! Contribute to ryanmjacobs/c development by creating an account on GitHub.
- 245TreeFrog Framework : High-speed C++ MVC Framework for Web Application
https://github.com/treefrogframework/treefrog-framework
TreeFrog Framework : High-speed C++ MVC Framework for Web Application - treefrogframework/treefrog-framework
- 246A simple C++ header-only template library implementing matching using wildcards
https://github.com/zemasoft/wildcards/
A simple C++ header-only template library implementing matching using wildcards - zemasoft/wildcards
- 247A modern formatting library
https://github.com/fmtlib/fmt
A modern formatting library. Contribute to fmtlib/fmt development by creating an account on GitHub.
- 248An open-source SDK for PSP homebrew development.
https://github.com/pspdev/pspsdk
An open-source SDK for PSP homebrew development. Contribute to pspdev/pspsdk development by creating an account on GitHub.
- 249Protocol Buffers with small code size
https://github.com/nanopb/nanopb
Protocol Buffers with small code size. Contribute to nanopb/nanopb development by creating an account on GitHub.
- 250A C/C++ minor mode for Emacs powered by libclang
https://github.com/Sarcasm/irony-mode
A C/C++ minor mode for Emacs powered by libclang. Contribute to Sarcasm/irony-mode development by creating an account on GitHub.
- 251Serial Port Programming in C++
https://github.com/crayzeewulf/libserial
Serial Port Programming in C++. Contribute to crayzeewulf/libserial development by creating an account on GitHub.
- 252Production-ready C++ Asynchronous Framework with rich functionality
https://github.com/userver-framework/userver
Production-ready C++ Asynchronous Framework with rich functionality - userver-framework/userver
- 253A Fast and Easy to use microframework for the web.
https://github.com/CrowCpp/Crow
A Fast and Easy to use microframework for the web. - CrowCpp/Crow
- 254A standalone and lightweight C library
https://github.com/attractivechaos/klib
A standalone and lightweight C library. Contribute to attractivechaos/klib development by creating an account on GitHub.
- 255Functional programming style pattern-matching library for C++
https://github.com/solodon4/Mach7
Functional programming style pattern-matching library for C++ - solodon4/Mach7
- 256Embedded C/C++ web server
https://github.com/civetweb/civetweb
Embedded C/C++ web server. Contribute to civetweb/civetweb development by creating an account on GitHub.
- 257Telegram Bot C++ Library
https://github.com/baderouaich/tgbotxx
Telegram Bot C++ Library. Contribute to baderouaich/tgbotxx development by creating an account on GitHub.
- 258Your high performance web application C framework
https://github.com/boazsegev/facil.io
Your high performance web application C framework. Contribute to boazsegev/facil.io development by creating an account on GitHub.
- 259🌱Light and powerful C++ web framework for highly scalable and resource-efficient web application. It's zero-dependency and easy-portable.
https://github.com/oatpp/oatpp
🌱Light and powerful C++ web framework for highly scalable and resource-efficient web application. It's zero-dependency and easy-portable. - oatpp/oatpp
- 260Visual Studio Code
https://github.com/microsoft/vscode
Visual Studio Code. Contribute to microsoft/vscode development by creating an account on GitHub.
- 261The password hash Argon2, winner of PHC
https://github.com/P-H-C/phc-winner-argon2
The password hash Argon2, winner of PHC . Contribute to P-H-C/phc-winner-argon2 development by creating an account on GitHub.
- 262Header-only C++11 library to encode/decode base64, base64url, base32, base32hex and hex (a.k.a. base16) as specified in RFC 4648, plus Crockford's base32. MIT licensed with consistent, flexible API.
https://github.com/tplgy/cppcodec
Header-only C++11 library to encode/decode base64, base64url, base32, base32hex and hex (a.k.a. base16) as specified in RFC 4648, plus Crockford's base32. MIT licensed with consistent, flexible...
- 263Pretty Printer for Modern C++
https://github.com/p-ranav/pprint
Pretty Printer for Modern C++. Contribute to p-ranav/pprint development by creating an account on GitHub.
- 264Tiny XML library.
https://github.com/michaelrsweet/mxml
Tiny XML library. Contribute to michaelrsweet/mxml development by creating an account on GitHub.
- 265stb single-file public domain libraries for C/C++
https://github.com/nothings/stb
stb single-file public domain libraries for C/C++. Contribute to nothings/stb development by creating an account on GitHub.
- 266A Template Engine for Modern C++
https://github.com/pantor/inja
A Template Engine for Modern C++. Contribute to pantor/inja development by creating an account on GitHub.
- 267A cross-platform Qt IDE
https://github.com/qt-creator/qt-creator
A cross-platform Qt IDE. Contribute to qt-creator/qt-creator development by creating an account on GitHub.
- 268CSerialPort - lightweight cross-platform serial port library for C++/C/C#/Java/Python/Node.js/Electron
https://github.com/itas109/CSerialPort
CSerialPort - lightweight cross-platform serial port library for C++/C/C#/Java/Python/Node.js/Electron - GitHub - itas109/CSerialPort: CSerialPort - lightweight cross-platform serial port library ...
- 269:zap: The Mobile Robot Programming Toolkit (MRPT)
https://github.com/mrpt/mrpt/
:zap: The Mobile Robot Programming Toolkit (MRPT). Contribute to MRPT/mrpt development by creating an account on GitHub.
- 270Open h.265 video codec implementation.
https://github.com/strukturag/libde265
Open h.265 video codec implementation. Contribute to strukturag/libde265 development by creating an account on GitHub.
- 271🦘 A dependency injection container for C++11, C++14 and later
https://github.com/gracicot/kangaru
🦘 A dependency injection container for C++11, C++14 and later - gracicot/kangaru
- 272Bear is a tool that generates a compilation database for clang tooling.
https://github.com/rizsotto/Bear
Bear is a tool that generates a compilation database for clang tooling. - rizsotto/Bear
- 273ita1024 / waf · GitLab
https://gitlab.com/ita1024/waf
The Waf build system
- 274MicroPython - a lean and efficient Python implementation for microcontrollers and constrained systems
https://github.com/micropython/micropython
MicroPython - a lean and efficient Python implementation for microcontrollers and constrained systems - micropython/micropython
- 275Protocol Buffers - Google's data interchange format
https://github.com/protocolbuffers/protobuf
Protocol Buffers - Google's data interchange format - protocolbuffers/protobuf
- 276C++ Discord API Bot Library - D++ is Lightweight and scalable for small and huge bots!
https://github.com/brainboxdotcc/DPP
C++ Discord API Bot Library - D++ is Lightweight and scalable for small and huge bots! - brainboxdotcc/DPP
- 277cppit / jucipp · GitLab
https://gitlab.com/cppit/jucipp
juCi++: a lightweight, cross-platform IDE
- 278A header only library for creating and validating json web tokens in c++
https://github.com/Thalhammer/jwt-cpp
A header only library for creating and validating json web tokens in c++ - Thalhammer/jwt-cpp
- 279FlatBuffers: Memory Efficient Serialization Library
https://github.com/google/flatbuffers
FlatBuffers: Memory Efficient Serialization Library - google/flatbuffers
- 280Semantic version in ANSI C
https://github.com/h2non/semver.c
Semantic version in ANSI C. Contribute to h2non/semver.c development by creating an account on GitHub.
- 281awesome-cpp/books.md at master · fffaraz/awesome-cpp
https://github.com/fffaraz/awesome-cpp/blob/master/books.md
A curated list of awesome C++ (or C) frameworks, libraries, resources, and shiny things. Inspired by awesome-... stuff. - fffaraz/awesome-cpp
- 282awesome-cpp/videos.md at master · fffaraz/awesome-cpp
https://github.com/fffaraz/awesome-cpp/blob/master/videos.md
A curated list of awesome C++ (or C) frameworks, libraries, resources, and shiny things. Inspired by awesome-... stuff. - fffaraz/awesome-cpp
- 283CppDepend - Boost Your C and C++ Code Quality.
https://www.cppdepend.com/
Improve your C and C++ code quality with CppDepend, the leading static analysis and code quality tool. Try it now and experience cleaner, more maintainable code!
- 284Jinja2 C++ (and for C++) almost full-conformance template engine implementation
https://github.com/jinja2cpp/Jinja2Cpp
Jinja2 C++ (and for C++) almost full-conformance template engine implementation - jinja2cpp/Jinja2Cpp
- 285Quick C++ Benchmarks
https://quick-bench.com/
Quickly benchmark C++ runtimes
- 286A modern C++ library for type-safe environment variable parsing
https://github.com/ph3at/libenvpp
A modern C++ library for type-safe environment variable parsing - ph3at/libenvpp
- 287Spack
https://spack.io/
A flexible package manager supporting multiple versions, configurations, platforms, and compilers.
- 288C++ Build Benchmarks
https://build-bench.com/
Compare build times of C++ code
- 289Simple Dynamic Strings library for C
https://github.com/antirez/sds
Simple Dynamic Strings library for C. Contribute to antirez/sds development by creating an account on GitHub.
- 290A Discord API wrapper library made in C
https://github.com/Cogmasters/concord
A Discord API wrapper library made in C. Contribute to Cogmasters/concord development by creating an account on GitHub.
- 291C++ Web Framework REST API
https://github.com/wfrest/wfrest
C++ Web Framework REST API. Contribute to wfrest/wfrest development by creating an account on GitHub.
- 292High performance C++11 signals
https://github.com/larspensjo/SimpleSignal
High performance C++11 signals. Contribute to larspensjo/SimpleSignal development by creating an account on GitHub.
- 293Implementation of python itertools and builtin iteration functions for C++17
https://github.com/ryanhaining/cppitertools
Implementation of python itertools and builtin iteration functions for C++17 - ryanhaining/cppitertools
- 294static analysis of C/C++ code
https://github.com/danmar/cppcheck
static analysis of C/C++ code. Contribute to danmar/cppcheck development by creating an account on GitHub.
- 295Anjuta DevStudio
https://sourceforge.net/projects/anjuta/
Download Anjuta DevStudio for free. Anjuta DevStudio is a versatile Integrated Development Environment (IDE) for software development on GNU/Linux. It features many advanced facilities such as project management, application wizards, interactive debugger, source browsing etc.
- 296Online C++ Compiler - Programiz
https://www.programiz.com/cpp-programming/online-compiler
Write and run your C++ code using our online compiler. Enjoy additional features like code sharing, dark mode, and support for multiple programming languages.
- 297libonion - Coralbits S.L.
http://www.coralbits.com/libonion/
Lightweight C library to add web server functionality to your program libonion is a lightweight library to help you create webservers in C programming language. These webservers may be a web application, a means of expanding your own application to give it web functionality or even a fully featured webserver. The user can create new […]
- 298Learn C++ - Best C++ Tutorials | Hackr.io
https://hackr.io/tutorials/learn-c-plus-plus
Learning C++? Check out these best online C++ courses and tutorials recommended by the programming community. Pick the tutorial as per your learning style: video tutorials or a book. Free course or paid. Tutorials for beginners or advanced learners. Check C++ community's reviews & comments.
- 299C++ Team Blog
https://devblogs.microsoft.com/cppblog/
C++ tutorials, C and C++ news, and information about Visual Studio, Visual Studio Code, and Vcpkg from the Microsoft C++ team.
- 300Rapid YAML - a library to parse and emit YAML, and do it fast.
https://github.com/biojppm/rapidyaml
Rapid YAML - a library to parse and emit YAML, and do it fast. - biojppm/rapidyaml
- 301CppExpert | The best way to Learn C++ for free
https://cppexpert.online
CppExpert is the best free platform to learn C++. Learn the best practices of C++ programming with CppExpert.
- 302Smart Swift/Objective-C IDE for iOS & macOS Development
http://www.jetbrains.com/objc/
An intelligent IDE for iOS/macOS development focused on code quality, efficient code navigation, smart code completion, on-the-fly code analysis with quick-fixes and superior code refactorings.
- 303A Cross-Platform IDE for C and C++ by JetBrains
http://www.jetbrains.com/clion/
A powerful IDE from JetBrains helps you develop in C and C++ on Linux, macOS and Windows.
- 304.NET programming with C++/CLI
https://docs.microsoft.com/en-us/cpp/dotnet/dotnet-programming-with-cpp-cli-visual-cpp?view=msvc-160
Learn how to use C++/CLI to create .NET apps and components in Visual Studio.
- 305Home · Wiki · GNOME / libxml2 · GitLab
http://xmlsoft.org/
XML parser and toolkit
- 306C++ quiz
https://quiz.pvs-studio.com
Test yourself. See if you can find all the bugs in the code.
- 307C++11/14/17/20 library for lazy evaluation
https://github.com/MarcDirven/cpp-lazy
C++11/14/17/20 library for lazy evaluation. Contribute to MarcDirven/cpp-lazy development by creating an account on GitHub.
- 308Ideone.com
http://ideone.com/
Ideone is something more than a pastebin; it's an online compiler and debugging tool which allows to compile and run code online in more than 40 programming languages.
- 309GotW
https://herbsutter.com/gotw/
Guru of the Week (GotW) is a series of C++ programming problems created and written by Herb Sutter. Starting in May 2013, GotW articles are currently being revised to match the upcoming C++14 ISO S…
- 310Dev-C++
http://sourceforge.net/projects/orwelldevcpp/
Download Dev-C++ for free. A free, portable, fast and simple C/C++ IDE. A new and improved fork of Bloodshed Dev-C++
- 311Mastering MISRA C++ Compliance with CppDepend.
https://www.cppdepend.com/misra-cpp
Discover the role of MISRA C++ in the automotive industry, a collaborative effort between vehicle manufacturers, component suppliers, and engineering consultancies to establish best practices for safety-related electronic systems in road vehicles and other embedded systems. Learn how CppDepend supports MISRA C++ compliance to achieve safer and more reliable software.
- 312Online Courses - Learn Anything, On Your Schedule | Udemy
https://www.udemy.com/topic/C-plus-plus-tutorials/
Udemy is an online learning and teaching marketplace with over 250,000 courses and 73 million students. Learn programming, marketing, data science and more.
- 313boostcon/cppnow_presentations_2022
https://github.com/boostcon/cppnow_presentations_2022
Contribute to boostcon/cppnow_presentations_2022 development by creating an account on GitHub.
- 314IDE and Code Editor for Software Developers and Teams
https://www.visualstudio.com/
Visual Studio dev tools & services make app development easy for any developer, on any platform & language. Develop with our code editor or IDE anywhere for free.
- 315C++ Tutorial | Learn C++ Programming Language - Scaler Topics
https://www.scaler.com/topics/cpp
This C++ tutorial on Scaler Topics will teach you all concepts in C++, from the fundamentals to the advanced concepts. Beginners and even professionals can easily follow this C++ tutorial.
- 316Repository for the slides and the code of my "Quick game development with C++11/C++14" CppCon 2014 talk.
https://github.com/SuperV1234/cppcon2014
Repository for the slides and the code of my "Quick game development with C++11/C++14" CppCon 2014 talk. - vittorioromeo/cppcon2014
- 317C/C++ language server supporting multi-million line code base, powered by libclang. Emacs, Vim, VSCode, and others with language server protocol support. Cross references, completion, diagnostics, semantic highlighting and more
https://github.com/cquery-project/cquery/
C/C++ language server supporting multi-million line code base, powered by libclang. Emacs, Vim, VSCode, and others with language server protocol support. Cross references, completion, diagnostics, ...
- 318Intel® oneAPI DPC++/C++ Compiler
https://software.intel.com/en-us/c-compilers
Compile for CPUs, GPUs, and FPGAs with an LLVM technology-based compiler that enables custom accelerator tuning and supports OpenMP for GPU offload.
- 319Replit – Build software faster
https://repl.it
Replit is an AI-powered software development & deployment platform for building, sharing, and shipping software fast.
- 320Presentation on Hana for C++Now 2015
https://github.com/ldionne/hana-cppnow-2015
Presentation on Hana for C++Now 2015. Contribute to ldionne/cppnow-2015-hana development by creating an account on GitHub.
- 321Eclipse CDT™ (C/C++ Development Tooling)
http://www.eclipse.org/cdt/
Eclipse CDT™ (C/C++ Development Tooling) has 7 repositories available. Follow their code on GitHub.
- 322Collaborative Collection of C++ Best Practices. This online resource is part of Jason Turner's collection of C++ Best Practices resources. See README.md for more information.
https://github.com/lefticus/cppbestpractices
Collaborative Collection of C++ Best Practices. This online resource is part of Jason Turner's collection of C++ Best Practices resources. See README.md for more information. - cpp-best-practic...
- 323ruslo/hunter
https://www.github.com/ruslo/hunter
Contribute to ruslo/hunter development by creating an account on GitHub.
- 324This project is obsolete. TinyXML-2 offers a very similar C++ interface.
https://github.com/rjpcomputing/ticpp
This project is obsolete. TinyXML-2 offers a very similar C++ interface. - wxFormBuilder/ticpp
- 325Suite of C++ libraries for radio astronomy data processing
https://code.google.com/p/casacore/
Suite of C++ libraries for radio astronomy data processing - casacore/casacore
- 326A C++ implementation of timsort
https://github.com/gfx/cpp-TimSort
A C++ implementation of timsort. Contribute to timsort/cpp-TimSort development by creating an account on GitHub.
- 327Drogon: A C++14/17/20 based HTTP web application framework running on Linux/macOS/Unix/Windows
https://github.com/an-tao/drogon
Drogon: A C++14/17/20 based HTTP web application framework running on Linux/macOS/Unix/Windows - drogonframework/drogon
- 328Cross-platform C++11 header-only library for memory mapped file IO
https://github.com/mandreyel/mio
Cross-platform C++11 header-only library for memory mapped file IO - vimpunk/mio
Related Articlesto learn about angular.
- 1Introduction to C++: Beginner's Guide to Getting Started
- 2C++ Variables, Data Types, and Operators
- 3Control Flow in C++: Conditionals and Loops
- 4C++ Object-Oriented Programming: Classes and Objects
- 5Templates and Generic Programming in C++: Comprehensive Guide
- 6C++ Memory Management: Pointers and Dynamic Allocation
- 7Building Your First C++ Application: Step-by-Step Guide
- 8C++ in Game Development: How to Get Started with Simple Games
- 9Best Practices for Writing Efficient and Maintainable C++ Code
- 10Advanced C++ Optimization: Performance in Critical Areas
FAQ'sto learn more about Angular JS.
mail [email protected] to add more queries here 🔍.
- 1
how long does it take to learn c++ programming
- 2
what c++ programming language
- 3
where to practice c++ programming
- 4
should i learn c++ or python
- 5
why was c++ invented
- 6
what are variables in c++ programming
- 7
which app is used for c++ programming
- 8
how to do c programming in turbo c++
- 9
what does mean in c++ programming
- 10
where c++ programming is used
- 11
how to learn c++ programming for beginners
- 13
is c++ programming language still used
- 14
why c++ is best for competitive programming
- 15
why was c++ developed
- 16
when is c++ used more often
- 17
what is c++ programming language definition
- 18
how to use dev c++ for c programming
- 19
why c++ procedural programming
- 20
what are strings in c++ programming
- 21
what is generic programming in c++
- 22
who developed c++ programming language
- 23
what does a c++ programmer do
- 24
where to learn c++ programming
- 25
where to learn c++ for competitive programming
- 26
when is c++ used
- 27
how to learn c++ programming language
- 28
why we use c++ programming language
- 29
who created c++ programming language
- 30
what can you do with c++ programming
- 31
how to do c++ programming in ubuntu
- 32
what are advantages of java programming over c++
- 33
what programming language is c++ written in
- 34
what c++ programming is used for
- 35
should i learn c++ or java first
- 36
how to practice c++ programming
- 37
how to use turbo c++ for c programming
- 38
should i learn c++ or python first
- 39
which app is best for c++ programming
- 40
how to learn c++ programming
- 41
can c++ run on mac
- 42
when was c++ programming language invented
- 43
does c++ support functional programming
- 44
is c++ a programming language
- 45
should i learn c++ as a beginner
- 46
what can i do with c++ programming language
- 47
what is an array in programming c++
- 48
why does c++ fail in web programming
- 49
can c and c++ be mixed
- 50
will c++ become obsolete
- 51
does c++ have a future
- 52
can c++ run on linux
- 53
how to do c++ programming in android phone
- 54
what are the function in c++ programming
- 55
should i learn c++ as my first language
- 56
where to download c++ programming language
- 57
what are the features of object oriented programming in c++
- 58
was c++ written in c
- 59
how to start c++ programming language
- 60
how can i learn c++ programming language
- 61
why c++ is the best programming language
- 62
what are the uses of c++ programming language
- 63
why is c++ used in competitive programming
- 64
can c++ call python
- 65
how to use c++ programming language
- 66
will c++ ever die
- 67
does c++ cost money
- 68
when c++ is mostly used
- 69
is c++ programming hard
- 70
who invented c++ programming language
- 71
which software is used for c++ programming
- 72
where to do c++ programming
- 73
how do i learn c++ programming language
- 74
how to make a programming language in c++
- 75
can c++ run c code
- 76
why is c++ called object oriented programming
- 77
how do you pronounce c++ programming language
- 78
what is c++ programming language in hindi
- 79
why is c++ object oriented programming
- 80
who updates c++
- 81
what is c++ programming with example
- 82
what are the characteristics of c++ programming language
- 83
what is introduction to c++ programming
- 84
what can you do with c++ programming language
- 85
why learn c++ programming
- 86
which programming language should i learn after c++
- 87
who uses c++ programming language
- 88
how to do c++ programming in windows 10
- 89
what is c++ programming language used for
- 90
what are the data types in c++ programming
- 91
how did c++ get its name
- 92
what is c++ in computer programming
- 93
who created c++
- 94
what is procedure oriented programming in c++
- 95
how to start learning c++ programming
- 96
what is c++ programming used for
- 97
is c++ programming language
- 98
is c++ good for software development
- 99
is c++ powerful
- 100
what is basic c++ program
- 101
what is c++ in coding
- 102
what is c++ programming pdf
- 103
which software is best for c++ programming
- 104
what is c++ programming
- 105
why is c++ important in programming
- 106
what are structures in c++ programming
- 107
when did c++ come out
- 108
what is object oriented programming in c++
- 109
when was c++ invented
- 110
when was c++ programming language created
- 111
why study c++ programming
- 112
will c++ be replaced
- 113
does c code work in c++
More Sitesto check out once you're finished browsing here.
https://www.0x3d.site/
0x3d is designed for aggregating information.
https://nodejs.0x3d.site/
NodeJS Online Directory
https://cross-platform.0x3d.site/
Cross Platform Online Directory
https://open-source.0x3d.site/
Open Source Online Directory
https://analytics.0x3d.site/
Analytics Online Directory
https://javascript.0x3d.site/
JavaScript Online Directory
https://golang.0x3d.site/
GoLang Online Directory
https://python.0x3d.site/
Python Online Directory
https://swift.0x3d.site/
Swift Online Directory
https://rust.0x3d.site/
Rust Online Directory
https://scala.0x3d.site/
Scala Online Directory
https://ruby.0x3d.site/
Ruby Online Directory
https://clojure.0x3d.site/
Clojure Online Directory
https://elixir.0x3d.site/
Elixir Online Directory
https://elm.0x3d.site/
Elm Online Directory
https://lua.0x3d.site/
Lua Online Directory
https://c-programming.0x3d.site/
C Programming Online Directory
https://cpp-programming.0x3d.site/
C++ Programming Online Directory
https://r-programming.0x3d.site/
R Programming Online Directory
https://perl.0x3d.site/
Perl Online Directory
https://java.0x3d.site/
Java Online Directory
https://kotlin.0x3d.site/
Kotlin Online Directory
https://php.0x3d.site/
PHP Online Directory
https://react.0x3d.site/
React JS Online Directory
https://angular.0x3d.site/
Angular JS Online Directory