I don't see how you're loading and not saving - you have a char array containing vertices and you want to load it into vertex.[xyz], correct? Then you want to use sscanf, not sprintf. Or better yet, a stringstream. If you really do want to put the vertices into c, then continue reading below.

First - make sure that vertex.[xyz] are all floats and not some other data type. (unlikely, but with printf you just have to be sure)

Second - I would be leery of using sprintf. If you're using C++ (which you are - you have delete[]) then use a stringstream. Just create a new stringstream, do << "[ " << vertex.x << " " << vertex.y and so on. Then you can grab a string out of it using >> (some string) and doing .c_str() on the string. If you have a preexisting char array you can then do a strncpy to it.

If you must use sprintf, use snprintf instead (it's called something like _snprintf on msvc) That way if you are accidentally overwriting your buffer then you will get an incomplete string instead of a blown away stack.

std::stringstream s << GetVertex();s >> std::ws;char p= s.peek();if(p != '[')   std::error();s.ignore();s >> vertex.x >> vertex.y >> vertex.z;s >> std::ws;p= s.peek();if(p != ']')   std::error();//done

not tested, but you get the idea... boost has such stuff already in function form, but i dont use boost frequently enough to tell you the functionnames

and now: pls stop using c functions ;)

T2k

Actually, say what you want about type safety BUT:

1) C functions can be largely checked for type safety by the compiler.
2) C functions are significantly faster - not like twice as fast but orders of magnitude
3) C functions are simpler to use (if you know the formatting commands); why do you think they made boost::format? (which by the way, is still slow)

Quote:Original post by Puzzler183
Actually, say what you want about type safety BUT:
1) C functions can be largely checked for type safety by the compiler.

void* and varargs, which C uses all over the place, are the anitithesis of type safety. In most cases they cannot be checked by the compiler, although in a few instances it's possible. Not to mention that printf has it's own vulnerability named after it. There's a reason you get "printf format string vulnerabilty" but never "iostream manipulater vulnerability".

Quote:Original post by Puzzler183
2) C functions are significantly faster - not like twice as fast but orders of magnitude

That has nothing to do with them being "C" functions, it's just because they're either less safe, less general, or less extensible.

The String Formatters of Manor Farm by Herb Sutter

Quote:Original post by Puzzler183
3) C functions are simpler to use (if you know the formatting commands); why do you think they made boost::format? (which by the way, is still slow)

No, C functions have more succinct operations for formatting. However, they are still resticted to built-in types, so are not simpler to use with custom data types:
Vector3D v( 3, 4, 5 );
printf( "%?", v ); // uhoh. Dies no matter what you put for ?
cout << v; // works fine
cout << boost::format( "%+05s" ) % v; // also works fine

Also, c-style I/O can only be used for the limited cases that it allows for. In C++, you can have cout write zlib-compressed data with just:
zlib_ostreambuf<char> zsb( cout.rdbuf() );
cout.rdbuf( zsb );
And then using cout as you normally would.

Quote:Original post by me22
In most cases they cannot be checked by the compiler, although in a few instances it's possible. Not to mention that printf has it's own vulnerability named after it.

Really? GCC's format string validator works great, except perphaps for dynamic formats (but such things are very rare, and there's no equivalent functionality in standard C++ library).
Just don't forget to mark your functions as such when making a printf wrapper.