How to avoid pointer arithmetic when using char** argv

Question

When trying to print the first command line argument:

std::cout << argv[0] << std::endl;

clang-tidy gives the warning:

warning: 'do not use pointer arithmetic' from [cppcoreguidelines-pro-bounds-pointer-arithmetic]

Is there an alternative way to use the values of argv without using pointer arithmetic? Isn't accessing a char** by any sensible method going to have to use pointer arithmetic?

I appreciate there are some specialised functions to handle command line arguments, but they seem too heavyweight for simply printing one argument.

I am writing in c++, using the clang compiler and building with cmake.

If you only need argv[0], you can use *argv. But beyond that, nope. — Benjamin Lindley
– Benjamin Lindley, Commented Aug 16, 2017 at 16:14
@spectras never an array. Function arguments cannot be arrays. — eerorika
– eerorika, Commented Aug 16, 2017 at 16:40
It's just implementation core guidelines ran amok. A better implementation should recognize the special case of main and stop bothering you about pointer arithmetic in this case. — SergeyA
– SergeyA, Commented Aug 16, 2017 at 16:54
@hvd Than guidelines should make an exception for main. It is a well-known interface which is not going to change, so why bother developers with this warning? — SergeyA
– SergeyA, Commented Aug 16, 2017 at 17:03
@SergeyA As I point out in my answer, it's possible to read the command-line arguments without changing the interface in a way that this guideline supports. But I do think it would be good if they at least address it. Whether that is by making an exception or by showing how to implement it without violating the guideline doesn't matter too much to me. — user743382
– user743382, Commented Aug 16, 2017 at 17:07

Mikhail · Accepted Answer · 2021-02-12 10:48:03Z

From clang-tidy - cppcoreguidelines-pro-bounds-pointer-arithmetic:

Pointers should only refer to single objects, and pointer arithmetic is fragile and easy to get wrong. span<T> is a bounds-checked, safe type for accessing arrays of data.

So yes:

Is there an alternative way to use the values of argv without using pointer arithmetic? Isn't accessing a char** by any sensible method going to have to use pointer arithmetic?

You're entirely correct. However, the guideline is about hiding that pointer arithmetic, letting a helper class do bounds checks before performing the arithmetic. You can construct a span<char*> from argv and argc. E.g. in C++20 you would write:

auto args = std::span(argv, size_t(argc));

and then use args instead of argv.

@SergeyA That sounds like you fundamentally disagree with the guideline. Which is perfectly fair, and in that case, don't turn on that warning.
I am in agreement with the majority of them, but this particular rule I find badly thought. A branch on every access is not what I ever want in my code.
"constexpr reference operator[](size_type idx) const; Returns a reference to the idx-th element of the sequence. The behavior is undefined if idx is out of range"
std::span accepts size as a size_t (unsigned type), while argc is an int (signed type). Without an explicit cast, there would be a warning about implicit signed->unsigned conversion.

Collectives™ on Stack Overflow

How to avoid pointer arithmetic when using char** argv

1 Answer 1

13 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

13 Comments

Related