Thread: A Question About C++ Template

(void) and if (0) are standard idioms for intentional do-nothing code, so no warnings will be produced by using them. However, in real code you likely won't need them, because the actual code you write will already take care of the checking for you. For example:

Code:

template<class T>
void f(T* obj) {
    for (auto s : *obj)
         cout << s.substr(0,2);
    cout << "\n";
}

The fact that f calls substr on the elements already implies to the compiler (and to the reader) that the elements must be strings or at least that they respond to 'substr' messages (presumably with the correct semantics). Explicit checks are not needed.

Originally Posted by c99tutorial

(void) and if (0) are standard idioms for intentional do-nothing code, so no warnings will be produced by using them.

They may be standard idioms in C, but this is C++. There's something wrong with the compiler if it doesn't complain.

However, in real code you likely won't need them, because the actual code you write will already take care of the checking for you. For example:

Yes, but as we've already discussed, this will provide a bunch of horrible error messages. You may not need them, but it is good practice to make assumptions explicit. It's a sort of self-documentation and it makes errors clearer.

The fact that f calls substr on the elements already implies to the compiler (and to the reader) that the elements must be strings or at least that they respond to 'substr' messages (presumably with the correct semantics).

It absolutely under no circumstances says no such thing. All it says is that type T must have a substr(int, int) member function, whatever that is. The compiler doesn't care if it's std::string or MyWeirdType that overloads substr. The compiler will do no optimizations or anything else.

Explicit checks are not needed.

Again, not needed, but a lot of things are not needed, but a lot of things made explicit makes code easier to maintain, read and understand.

Btw, your code makes a copy of every element in obj, which is probably not what you want. You should be using references and std::vector/std::array, not a raw pointer. That is bad practice in C++.

(void) and if (0) are standard idioms for intentional do-nothing code, so no warnings will be produced by using them.

This is wrong enough to misinform. (void) does not mean "do nothing code" in any technical sense. Casting like this is an explicit way to say that the return value of some statement will be ignored. The only reason here it doesn't run is because if (0) never executes code underneath it.

Code:

#include <cstdio>
int main() {
   (void) std::printf("hello, world\n");
}

// my result: hello, world

if (0) was only common practice in C, as a specific use of goto to handle cleanup or other operations at the end of a function if an error occured. With RAII and exception handling, this practice is not needed in C++ at all.

If anything, this code sounds like it needs to be written in terms of iterators whose value type is `char`. That way, it's zounds more readable, probably more well-behaved and more natural to C++.

I consent with Mutant John too. I was trying to think of what code would really work like what OP wants. The first thing I thought of doing was getting iterators from the container passed in and then using the STL. So maybe just writing the code with iterators will be enough.

Originally Posted by Antigloss

To convert any container holding strings to an array holding c strings.

It sounds like MutantJohn's suggestion of iterators would be your overall best solution, i.e., write an algorithm that takes two input iterators denoting the beginning and one past the end of a range, and that has the content of an array of null terminated C-style strings as output.

Originally Posted by Antigloss

To convert any container holding strings to an array holding c strings.

But why would you do that?