assert() with message

Question

I saw somewhere assert used with a message in the following way:

assert(("message", condition));

This seems to work great, except that gcc throws the following warning:

warning: left-hand operand of comma expression has no effect

How can I stop the warning?

See [this](http://stackoverflow.com/questions/5665611/why-does-this-code-produce-a-warning-referring-to-the-comma-operator) related question. — razlebe, May 03 '11 at 10:00

pmg · Accepted Answer · 2011-05-03T10:29:59.357

96

Use -Wno-unused-value to stop the warning; (the option -Wall includes -Wunused-value).

I think even better is to use another method, like

assert(condition && "message");

edited May 03 '11 at 10:29

answered May 03 '11 at 10:10

pmg

106,608
13
126
198

11

Nice one, I usually do assert(condition /* message */). – Julien Jan 22 '13 at 08:22
This sometimes gives "Conditional expression is constant" warning in Visual Studio. Any ideas on how to remove the warning without suppressing it? – Samaursa Apr 04 '13 at 23:56
@Samaursa: you probably have an issue with plain `condition`. Does the compiler also warn with just `assert(condition);`? – pmg Apr 05 '13 at 09:35
It does not. The interesting thing is that OP's original problem code is the solution to VS's warnings! `assert((Msg, Cond));` works without warnings on VS 2008. – Samaursa Apr 05 '13 at 19:58
`assert(() && "msg");` causes CppCheck (v1.90) to generate an "incorrectStringBooleanError" warning. – ahogen Dec 04 '19 at 22:35

score 24 · Answer 2 · edited Jan 03 '16 at 21:35

24

Try:

#define assert__(x) for ( ; !(x) ; assert(x) )

use as such:

assert__(x) {
    printf("assertion will fail\n"); 
}

Will execute the block only when assert fails.

IMPORTANT NOTE: This method will evaluate expression x twice, in case x evaluates to false! (First time, when the for loop is checking its condition; second time, when the assert is evaluating the passed expression!)

edited Jan 03 '16 at 21:35

Peter Varo

11,726
7
55
77

answered Jun 09 '12 at 08:20

bugfeeder

349
2
2

4

The nice thing about this is that you can omit the message if you want by using `assert__(foo);` and the semicolon will end the block. – Kevin Cox Jun 10 '14 at 14:29
2

Such implementation will not work if `(x)` returns true only once: `string("a") a; assert__(a.append("b") == "ab") { ... }` – Oleg Nov 27 '15 at 14:34
3

Why `for` and not `if`? – Caridorc Jan 03 '16 at 22:10
This does not seem to work in GCC. Failing `assert` stops the program execution and `printf` is not called. – VLL May 20 '21 at 12:04
@vil It is not possible for `assert` to stop the program before `printf` because `assert` is not called until after `printf`. – Jack G Oct 22 '21 at 22:11

frmdstryr · Answer 3 · 2014-03-29T15:48:47.050

If you want to pass a formatted message, you could use the following macros:

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <assert.h>

#define clean_errno() (errno == 0 ? "None" : strerror(errno))
#define log_error(M, ...) fprintf(stderr, "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, clean_errno(), ##__VA_ARGS__)
#define assertf(A, M, ...) if(!(A)) {log_error(M, ##__VA_ARGS__); assert(A); }

Then use it like printf:

// With no args
assertf(self != NULL,"[Server] Failed to create server.");

// With formatting args
assertf((self->socket = u_open(self->port)) != -1,"[Server] Failed to bind to port %i:",self->port);
// etc...

Output:

[ERROR] (../src/webserver.c:180: errno: Address already in use) [Server] Failed to bind to port 8080: webserver: ../src/webserver.c:180: server_run: Assertion `(self->socket = u_open(self->port)) != -1' failed.

Based on http://c.learncodethehardway.org/book/ex20.html

This, unfortunately, isn't portable. C99 requires that you use at least one of the optional arguments in a variadic macro (e.g this: `assertf(x == y, "x does not equal y")` violates the standard. This is easily rectified via `assertf(x == y, "%s", "x does not equal y")` however). It also relies on the gcc extension `##__VA_ARGS__` which isn't necessarily a bad thing, but it does make it less portable — chad, Sep 14 '15 at 17:49

score 2 · Answer 4 · answered Nov 11 '19 at 10:02

2

By tradition, (void) communicates to the compiler that you are knowingly ignoring an expression:

/* picard.c, TNG S6E11. */
#define assertmsg(x, msg) assert(((void) msg, x))
assertmsg(2+2==5, "There! are! four! lights!");

answered Nov 11 '19 at 10:02

Mingye Wang

1,107
9
32

Flaviu · Answer 5 · 2021-05-21T05:27:47.520

2

For unexpected default case of a switch, an options is

assert(!"message");

edited May 21 '21 at 05:27

answered May 08 '21 at 02:31

Flaviu

931
11
16

1

This seems to be always false. Where is the condition that is being tested? – VLL May 20 '21 at 11:47
This useful for unexpected default case of a switch. – Flaviu May 21 '21 at 05:27
1

That, while true, doesn't have anything to do with the original question. – john-g Aug 10 '21 at 21:25

JiaHao Xu · Answer 6 · 2020-03-29T06:17:46.263

0

A function that takes const char* and returns true would probably save you from all sorts of warnings:

#include <assert.h>

int always_true(const char *msg) {
    return 1;
}

#define assert_msg(expr, msg) assert((expr) && always_true(msg))

edited Mar 29 '20 at 06:17

answered Mar 29 '20 at 03:56

JiaHao Xu

2,452
16
31

1

Definitely not from "unused parameter" warnings. – DanielM Oct 12 '22 at 09:00

user9869932 · Answer 7 · 2021-05-26T19:24:06.137

0

In my case, I changed @pmg's answer to be able to control the output. The (... && "message") didn't work for me.

#include <assert.h>
#include <stdio.h>

#define __DEBUG__ 1

assert ((1 == 1) && 
       (__DEBUG__ && printf("  - debug: check, ok.\n")) || !__DEBUG__);

edited May 26 '21 at 19:24

answered May 20 '21 at 11:31

user9869932

6,571
3
55
49

Try `NDEBUG` instead of `__DEBUG__`. It's the standard way to do this as defining `NDEBUG` automatically disables all `asset`s. – Jack G Aug 15 '22 at 18:13

alx - recommends codidact · Answer 8 · 2019-09-24T14:54:31.263

You could write your own macro that provides the same usage of _Static_assert(expr, msg):

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>


/*
 * void assert_msg(bool expr, const char *msg);
 */
#if !defined(NDEBUG)
#define assert_msg(expr, msg)   do                  \
{                                                   \
        const bool  e_ = expr;                      \
                                                    \
        if (!e_) {                                  \
                fputs(msg, stderr);                 \
                fputc('\n', stderr);                \
                assert(e_);                         \
        }                                           \
} while (0)
#else
#define assert_msg(expr, msg)   do                  \
{                                                   \
                                                    \
        if (!(expr))                                \
                warn_bug(msg);                      \
} while (0)
#endif

I also have a macro warn_bug() that prints the name of the program, the file, the line, the function, the errno value and string, and a user message, even if asserts are disabled. The reason behind it is that it won't break the program, but it will warn that a bug will probably be present. You could just define assert_msg to be empty if defined(NDEBUG), though.

score -11 · Answer 9 · answered May 03 '11 at 10:13

-11

According to following link http://www.cplusplus.com/reference/clibrary/cassert/assert/

assert is expecting only expression. May be you are using some overloaded function.

According to this, only expression is allowed and thus you are getting this warning.

answered May 03 '11 at 10:13

Dhiraj

5
1

4

The inner parenthesis make it ok: `assert( ("message", condition) );` This is C: no overloading. – pmg May 03 '11 at 10:19
1

Don't see what relevance a C++ website has to a C question. – Lightness Races in Orbit Oct 21 '12 at 23:27

assert() with message

9 Answers9

Linked