9

Using the -Wunused-parameter flag, you can enforce __unused for unused parameters, as a compiler optimization. The following code causes two warnings:

#include <stdio.h>
int main(int argc, char **argv) {
  printf("hello world\n");
  return 0;
}

These warnings are fixed by adding __unused the unused arguments.

#include <stdio.h>
int main(int __unused argc, char __unused **argv) {
  printf("hello world\n");
  return 0;
}

When you use a parameter marked __unused, clang 4.1 does not warn or error.

#include <stdio.h>
int main(int __unused argc, char __unused **argv) {
  printf("hello world. there are %d args\n", argc);
  return 0;
}

The same behavior is exhibited using __attribute__((unused)).

int main(int __attribute__((unused)) argc, char __attribute__((unused)) **argv) {

Is there a way to warn or error on __unused? What would happen should you accidentally leave an __unused on a used parameter? In the above example argc appears to have the correct value, although it could be the compiler not taking advantage of the hint, and I wouldn't rely on this behavior without more understanding.

Improve this question
3
  • I've substantially edited the question to use C sample code instead of Objective-C to demonstrate that this is a C language question. Also, noted that the flag is -Wextra instead of -Wunused. Commented Jan 24, 2013 at 23:29
  • 1
    It's actually the -Wunused-parameter flag that's relevant here. The -Wextra flag enables -Wunused-parameter if -Wunused is specified, which is also implied by -Wall, but -Wextra is not enough by itself. Commented Jan 25, 2013 at 1:49
  • It sounds like you want to use __attribute__((deprecated)), which will warn when something is used. Commented Jan 25, 2013 at 1:50

3 Answers 3

Reset to default
12

The __unused attribute is intended to prevent complaints when arguments to functions/methods or functions/methods are unused, not to enforce their lack of use.

The term used in the GCC manual is:

This attribute, attached to a function, means that the function is meant to be possibly unused

And for variables:

This attribute, attached to a variable, means that the variable is meant to be possibly unused.

The most common use is for development against an interface - e.g. callbacks, where you may be forced to accept several parameters but don't make use of all of them.

I use it a bit when I'm doing test driven development - my initial routine takes some parameters and does nothing, so all the parameters take __attribute__((unused)). As I develop it I make use of the parameters. At the end of development I remove them from the method, and see what shakes out.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

My understanding is that it was a compiler hint, that you don't necessarily need the value to be available, which should cause issues if you're using it. I get the same behavior with __attribute__((unused)).
It's not an optimization hint - calling conventions would require the parameter to be present. In the same way as declaring a register variable should not result in an error if you don't have any registers left to use.
3

Another way to skin this cat is to remove (or comment out) the name of the parameter.

int main ( int argc, char ** /* argv */ ) {
    printf("hello world. there are %d args\n", argc);
    return 0;
}

Now the compiler won't warn about argv being unused, and you can't use it, because it has no name.

Improve this answer

7 Comments

This, for me, is definitely the way to go: the compiler doesn't need to know nor care; and you physically cannot use the parameters you want to leave unused! Be sure to note this convention down somewhere though so that it's not mistaken for sloppy programming.
Clang/LLVM doesn't like this --- I get a "Parameter name omitted" error and I can't find any compiler flag that might disable this. Petesh's answer works well, though.
@big_m: I suspect there's something else going on here, because I use code just like that all the time. Can you post some code?
@big_m: Sorry - I see what's going on. I was building with C++ enabled. If I build with C, then I get the "parameter name omitted". Sorry for the confusion.
That's an interesting find, @Marshall. An error for C (and functions in Objective-C), but not for C++. Odd. Perhaps it's part of the C++ language definition. In any case, I think it's great to have all the options documented here.
|
2

You can use deprecated and unused together to achieve the desired behavior (thanks to Dietrich Epp for mentioning deprecated in his comment):

#define is_unused __attribute__((deprecated, unused))

When the entity is actually unused, this will silence the warning. When an entity is flagged with this macro but still used, you'll get a deprecation warning.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.