gpakosz/PPK_ASSERT — dự án backend — đang có 208 sao GitHub trong nhóm Backend. PPK_ASSERT is an orthodox drop-in & self-contained C++ assertion library ⚠️
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Assert: a cross platform drop-in + self-contained C++ assertion library
TLDR
#include <boost/assert.hpp>
#include <sstream>
int main()
{
float min = 0.0f;
float max = 1.0f;
float v = 2.0f;
BOOST_ASSERT_MSG(v > min && v < max, static_cast<std::ostringstream&>(std::ostringstream().flush() << \
"invalid value: " << v << ", must be between " << min << " and " << max).str().c_str());
return 0;
}
vs
#include <ppk_assert.h>
int main()
{
float min = 0.0f;
float max = 1.0f;
float v = 2.0f;
PPK_ASSERT(v > min && v < max, "invalid value: %f, must be between %f and %f", v, min, max);
return 0;
}
Now which do you prefer? I know which I prefer.
Just drop ppk_assert.h and ppk_assert.cpp into your build and get
started. (see also customizing compilation)
Why?
It all started with the need to provide a meaningful message when assertions
fire. There is a well-known hack with standard assert to inject a message next
to the expression being tested:
assert(expression && "message");
But it's limited to string literals. I wanted improve on assert() by
providing the following features:
being able to format a message that would also contain the values for
different variables around the point of failure
having different levels of severity
being able to selectively ignore assertions while debugging
being able to break into the debugger at the exact point an assertion fires
(that is in your own source code, instead of somewhere deep inside assert
implementation)
no memory allocation
no unused variables warning when assertions are disabled
What?
The library is designed to be lightweight would you decide to keep assertions
enabled even in release builds (#define PPK_ASSERT_ENABLED 1).
By default, each assertion eats up sizeof(bool) of stack, used to keep track
whether the assertion should be ignored for the remaining lifetime of the
program. You can disable this feature (see customizing compilation).
The default handler associates a predefined behavior to each of the different
levels:
WARNING <= level < DEBUG: print the assertion message to stderr
DEBUG <= level < ERROR: print the assertion message to stderr and prompt
the user for action (disabled by default on iOS and Android)
ERROR <= level < FATAL: throw an AssertionException
FATAL < level: abort the program
If you know you're going to launch your program from within a login shell
session on iOS or Android (e.g. through SSH), define the
PPK_ASSERT_DEFAULT_HANDLER_STDIN preprocessor token.
When prompting for user action, the default handler prints the following
message on stderr:
Ignore Forever: remember the file and line where the assertion fired and
ignore it for the remaining execution of the program
Ignore All: ignore all remaining assertions (all files and lines)
Debug: break into the debugger if attached, otherwise abort() (on Windows,
the system will prompt the user to attach a debugger)
Abort: call abort() immediately
Under the Windows platform, the default handler also uses OutputDebugString
and in the case of a GUI application allocates a console upon encountering the
first failed assertion.
Under the Android platform, the default handler also sends log messages to the
in-kernel log buffer, which can later be accessed through the logcat utility.
The default handler supports optional logging to a file (suggested by
@nothings):
#define PPK_ASSERT_LOG_FILE "/tmp/assert.txt"
to truncate the log file upon each program invocation, #define PPK_ASSERT_LOG_FILE_TRUNCATE
Providing Your Own Handler
If you want to change the default behavior, e.g. by opening a dialog box or
logging assertions to a database, you can provide a custom handler with the
following signature:
typedef AssertAction::AssertAction (*AssertHandler)(const char* file,
int line,
const char* function,
const char* expression,
int level,
const char* message);
Your handler will be called with the proper information filled and needs to
return the action to be performed:
Arguably, unused return values are better of detected by the compiler. For
instance GCC and Clang allow you to mark function with attributes:
__attribute__((warn_unused_result)) int foo();
Which will emit the following warning in case the return value is not used:
warning: ignoring return value of function declared with warn_unused_result attribute [-Wunused-result]
However there is no MSVC++ equivalent. Well there is __checkReturn but it
supposedly only have effect when running static code analysis and I failed to
make it work with Visual Studio 2013 Express. Wrapping PPK_ASSERT_USED
around a return type is a cheap way to debug a program where you suspect a
function return value is being ignored and shouldn't have been.
When compiled with a C++11 capable compiler, PPK_STATIC_ASSERT defers to
static_assert. Contrary to static_assert, it's possible to use
PPK_STATIC_ASSERT without a message.
Customizing compilation
In order to use PPK_ASSERT in your own project, you just have to bring in
the two ppk_assert.h and ppk_assert.cpp files. It's that simple.
You can customize the library's behavior by defining the following macros:
#define PPK_ASSERT_ENABLED 1 or #define PPK_ASSERT_ENABLED 0: enable
or disable assertions, otherwise enabled state is based on NDEBUG
preprocessor token being defined
PPK_ASSERT_DEFAULT_LEVEL: default level to use when using the
PPK_ASSERT macro
PPK_ASSERT_DISABLE_STL: AssertionException won't inherit from
std::exception
PPK_ASSERT_DISABLE_EXCEPTIONS: the library won't throw exceptions on
ERROR level but instead rely on a user provided throwException function
that will likely abort() the program
PPK_ASSERT_MESSAGE_BUFFER_SIZE
PPK_ASSERT_DISABLE_IGNORE_LINE: disables the injection of a static bool
variable used to keep track whether the assertion should be ignored for the
remaining lifetime of the program
PPK_ASSERT_DEBUG_BREAK: lets you redefine programmatic breakpoints
If you want to use a different prefix, provide your own header that includes
ppk_assert.h and define the following:
You will have to install the Android NDK, and point the $NDK_ROOT environment
variable to the NDK path: e.g. export NDK_ROOT=/opt/android-ndk (without a
trailing / character).
Next, the easy way is to make a standalone Android toolchain with the following
command:
gpakosz/PPK_ASSERT thuộc nhóm Backend trên TopGit, cùng 3 topic GitHub. Trang Trending và Topics liệt kê các repo cùng số sao và cùng ngôn ngữ để so sánh.
Đọc thêm về gpakosz/PPK_ASSERT ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/gpakosz/PPK_ASSERT là nguồn chính thức.
gpakosz/PPK_ASSERT có phải mã nguồn mở không?
TopGit chưa ghi nhận license cho gpakosz/PPK_ASSERT. Phần lớn repo public trên GitHub là mã nguồn mở, nhưng điều khoản khác nhau từng repo — mở file LICENSE để xác nhận.
gpakosz/PPK_ASSERT là gì?
gpakosz/PPK_ASSERT (gpakosz/PPK_ASSERT) là dự án C++ trên GitHub. Theo mô tả gốc: PPK_ASSERT is an orthodox drop-in & self-contained C++ assertion library ⚠️
gpakosz/PPK_ASSERT so với các dự án Backend khác thế nào?
gpakosz/PPK_ASSERT được TopGit xếp vào nhóm Backend, với 208 sao GitHub và viết bằng C++. Xem trang chủ đề Backend trên TopGit để so sánh với các dự án tương tự theo số sao và mức độ hoạt động.
Vì sao gpakosz/PPK_ASSERT được xếp vào nhóm Backend?
TopGit xếp gpakosz/PPK_ASSERT vào nhóm Backend dựa trên GitHub topics và mô tả của repo (gắn thẻ: "assert", "cpp", "debug"). Việc phân loại dựa trên metadata thật của repo, không phải đoán theo cảm tính biên tập.
Đọc đầy đủ README ở tab phía trên.
PPK_ASSERT có đáng để bạn bỏ thời gian?
ChatGPT, Claude và Perplexity đều đọc được trang này. Hỏi thử xem họ nghĩ gì về PPK_ASSERT.