Printable View
I've been writing my own implementation of quicksort in a .h file. I've gotten to the point where I think I'm done with the algorithm, so now I'm trying to make it so that if someone includes "quicksort.h", they will only have access to certain functions in the file. Kind of like public and private functions in a class, but without the "class" part of it. How do you do that? And if there's any other information you need, let me know!
I would think the best approach is just to use two header files and only distribute the one with the public functions.
If your quicksort function is not a template, you can put the implementation in a cpp file. The "private" functions can be placed inside an anonymous namespace to prevent anyone from using them outside the cpp file.
If you have a template function, then code that uses it will need to see the implementation, so the only thing you can do it put the "private" functions inside a namespace (e.g. "detail") that indicates that they are implementation details.
Alright, I can see this working well, so now I just need to figure out how to properly distribute .h's so I don't lose the "private" functions. Thank you!Quote:
Originally Posted by GCDEF
They are template functions, and unfortunately, I'd rather not use a namespace since that apparently (I only have 2 quarters of university C++ under my belt) stops the user from using a different namespace (but correct me if I'm wrong). Also, if I did do what you suggested, would the "private" functions still need their own .cpp, or would it all be in the single .h? Thanks!Quote:
Originally Posted by D_Drmmr
If they are templates, then everything goes into .h files. There will be no .cpp file, unless you have parts that don't depend on a parametrized type.Quote:
Originally Posted by Leonhart231
The standard thing to do is usually to put your "public" methods where you want them to be (either mainspace, or a library namespace), and then to put the "private" methods inside a sub namespace called "implementation" or "details" or similar. This means the client will not be bothered by your private functions, or accidentally call them.
This is usually good enough, as calling your private methods can only be done deliberately and with full knowledge of doing something wrong. At this point, you can't stop them from doing what they want, and the behavior of their program seizes to be your problem anyways.
Ah, excellent! That worked perfectly, and it's a little cleaner than a second .h. Thanks for the help!Quote:
Originally Posted by monarch_dodra
If this is an assignment, cool. For future reference, however, be aware that it is very difficult to do better than the standard library's std::sort() method.
Might be better to sayQuote:
Originally Posted by Lindley
it is very difficult to do better than the standard library's std::sort() method as a general purpose sorter.
For specific cases, you can always come up with something better.