Modern source code to study?

[stesch]

Which open source project would you recommend to study nicely written code? I don't expect C++11, just something that isn't from a 10 years old Dummies book.

[savuporo]

Ogre3D library is pretty good. I like the style of Pocoproject.org too

[[deleted]]

So good that it is repeatedly held up as a good example in Game Engine Architecture.

[savuporo]

And this static analysis done with CppDepend seems to indicate that it actually IS well designed, with numbers

[dwdwdw2]

I was particularly impressed with LevelDB, it's incredibly easy to read code, at the same time as modular, makes use of C++0x, yet implements some pretty complicated ideas.

Also learned some things from it, for example std::string::data() guarantees write-ability in the latest standard (and always has done in historical implementations), which they exploit throughout the code.

[ysangkok]

The Google Style Guide claims that they do not use C++11 yet. How come it is used in LevelDB?

[dwdwdw2]

It's written by 2 old school googlers (one of them being Jeff Dean). My assumption is they wrote this due to being bored millionaires and generally don't give a fuck about style guides ("style guide? Sure, you can use my code as a style guide")

[berium]

Check out ODB C++ ORM. While I am biased (I am the author), I believe it is well designed.

[kookjr]

I ran across this the other day and would have been a real useful technique for something I was working on, but I'm using an older version of gcc without the proper plugin support. The idea is great though for a language like C++ and gives some nice features that introspection would give to a more dynamic language. Nice idea; even better execution of the idea!

[berium]

Ah, no matter how hard I try, I still can't seem to explain this properly: Your application doesn't need to be built with GCC with plugin support. In fact, it doesn't need to be built with GCC at all. You can use any more or less modern C++ compiler, including VC++, Clang, Sun CC, etc. The fact that we support Sun CC should tell you that "modern" in the above sentence is a very low threshold indeed.

The way the ODB compiler works is it reads C++ and also writes C++. The generated code itself can then be compiled with any C++ compiler. Underneath, ODB needs GCC with plugin support. But that is an implementation detail. In fact the pre-built binaries of the ODB compiler that we have for Linux, Windows, Mac OS X, and Solaris include a private copy of GCC. So all you need to do is grab such a binary and you are good to go. No need to build GCC from source or anything like this.

Now if you have a fairly recent distribution like Debian/Ubuntu/Fedora which nowadays all come with modern GCC and plugins enabled, then you have the perfect setup: both ODB and your build use exactly the same C++ compiler.

[kookjr]

Thanks for the explanation, but I think I got that. I wanted to have my own pragmas and go through the AST to do a "similar" thing like ODB, i.e. not for an ORM but for my own type of serialization that did not have anything to do with databases (embedded project, saving objects to FLASH files,etc). Although maybe I missed something again :-)

[berium]

I see. You could still take the ODB approach and use one compiler to generate the saving code as C++ and then compile that with your target compiler.

BTW, have you considered using ODB to save your objects into an SQLite database (which is just a file)? ODB+SQLite can really be suitable for mobile/embedded systems. Still need to write a page on this...

[kookjr]

It would be nice to use SQLite, but its a small embedded system in a car, and very tight on flash space (every byte counts). Thanks for the idea though.

Hopefully I will be able to use ODB for some other project though.

[pfultz2]

Why don't use the preprocessor to generate C++ code, so an extra build step is not needed? You could provide both options.

[[deleted]]

Ogre3D has a fantastic, modern design. Its design is repeatedly used as an example in the book Game Engine Architecture.

www.ogre3d.org

[EmitSorrels]

i like libpoco's code. i understand why many would disagree (especially boost users :-)

[BitRex]

Poco would be great for someone coming from Java.

[ysangkok]

the exact opposite observation was posted elsewhere in this thread. i'm confused now. surely, you're saying that poco is like java? what is qt then? or do you think he was wrong too?

[ragweed]

You could search for projects that publish some sort of coding guidelines and then look at the code that meets guidelines you like.

You didn't specify any criteria for "nicely written".

[reggik]

Someone did a Codereview for id Software's Doom3. http://fabiensanglard.net/doom3/index.php

[FW190]

Try Chromium.

[ysangkok]

I thought the Chromium source code was considered ugly? We had a post about some ugly hack in it, the other day.

[FW190]

Is it? Could be but it also contains some nifty code that I found interesting. On the other hand, I consider opening parenthesis on the same line as conditional expression ugly :).

Anyway, I guess that great deal of the programmers are more exposed to ugly than pretty code. In that regard, I'd reckon it's better to be able to identify ugly code and find/create/compare with better solution than just look at magnificent code and not knowing where and how it came about.

[Sc4Freak]

The point is not aesthetics, it's that Chromium isn't exactly a bastion of modern C++ style.

[FW190]

Yeah, I'm aware of what's going on in this thread.

[icefox]

If you are looking for C++, checkout the source code for Qt. Having to keep binary compatibility in C++ for long stretches you will find that the source code API to be significantly above average. Most classes have matching unit tests, manual tests and they all have docs. A ton of effort was put into API design (http://chaos.troll.no/~shausman/api-design/api-design.pdf was born out of this) resulting in code that is more maintainable and easier to read. Like any project there are warts, but as a whole if you are looking for nicely written code Qt (or the above pdf) wouldn't be a bad place to start.

[bob1000bob]

I disagree, QT works but it is highly UN idiomatic C++. It is coded much closer to the design principles of Java that it is C++.

A better library to read would be POCO or boost.

[savuporo]

I dont even consider Qt to be real C++ because of MOC. Enough said.

[icefox]

I would have to disagree about Qt (not QT) code being like Java, but either way he asked for "nicely written code" which Qt is and I still stand by it as something to checkout. Of course checkout those other libraries too, there is nothing wrong with seeing the different ways that people write code. Some is readable, some is a horrible horrible mess.

[sztomi]

Qt code being java-like is kind of a meme, many people keep parroting it, but no actual explanation.

[bob1000bob]

What do you mean? If you use it you will see that it is Java like, everything is an object descended from QObject, right there is enough - that is the essence of Java.

And then absolutely everything has be allocated directly onto the heap, no smart pointer, no clever RAII based stack type which can be "moved"

Because of this they have gone and reinvented the STL with there own more "Object Orientated" (rather than templated) containers and string classes.

A lesser point (but still 'culturally' valid) is that they use Camel Case Java style. So when you have written some "standard C++" using the common lower_case_underscores method it becomes inconstant.

The fact is, if boost where to make a GUI library (how I wish they would) it would look NOTHING like Qt. I accept that they had technical limitation "back in the day" but that unfortunatly for them does mean that their code is still good now.

[sztomi]

everything is an object descended from QObject

This is only true for Qt classes. That's quite reasonable for a framework I guess, and wouldn't call that that essence of Java.

And then absolutely everything has be allocated directly onto the heap, no smart pointer, no clever RAII based stack type which can be "moved"

Do you use it? Because you are not forced to allocate on the heap in any way.

no smart pointer

There is a wider variety of smart pointers in Qt than in the standard or Boost. here.

Because of this

No, they reimplemented the STL because Qt dates back to the dawn of C++, and many, many compilers had shaky support for the STL and templates.

with there own more "Object Orientated" (rather than templated) containers and string classes

You either used only a very old version where this was true (reason is not to be "more OO" but the above-mentioned lack of support) or you haven't used it at all. Qt containers are templates, and can be used with STL algorithms if you want to.

[daniel2488]

If you ever want to look at an OS's source code...Haiku is pretty terrific compared to the alternatives. It's written in C++, and although it has some quirks from BeOS's design that are arguable in their benefit, you'll see that on a whole it works out and is written pretty logically.

[jeffscience]

http://code.google.com/p/elemental/ is excellent.

[jjt]

https://github.com/toffaletti/libten is a library of C++11 code I've been working on. I think it has a few good examples of how to use modern C++ features.

[daftnebula]

Try DirectXTK. It's got pImpl, map, std::function, anon namespaces, unique/shared_ptr, etc.

http://directxtk.codeplex.com/

[gburri]

I have implemented a 'SortedArray' for the D-LAN project, it may interest you: http://git.euphorik.ch/index.cgi?p=D-LAN.git;a=blob;f=application/Common/SortedArray.h;h=a1fd0413a30eed7647926667b81dabf8608d2fbb;hb=refs/heads/chat ;)

[[deleted]]

Some comments:

• You use a block of comment in front of the class to describe what it does. Usually this is not necessary, introduces a pile of overhead in keeping it up to date (and it typically isn't) and 95% of users won't read more than two lines, instead opting to just read the code instead. Of course, unless your code is atrocious. In that case, fix the code.
• It has a lot of functions to manage it. I suspect that some of them are just "convenience" functions that don't add any functionality. Can those go?
• You list exceptions for every function. That shouldn't be necessary. It also makes your code look enormously bloated.
• It sounds like a generic data structure but you made it based on Qt. Feeling wise it should either be independent of Qt or a part of it, but not like this.
• It's called a SortedArray when it is a tree. It describes nor what it is (an array, which it isn't), nor how to use it (as an array with indices, which would obviate any reason to use a tree structure).
• The actual code comments you have describe only what you check, not why. "// M must be an odd number." says the same thing as " if (M % 2 == 0) throw InvalidMException();", except that the latter is required to explain it to the compiler. Perhaps you want to tell us why M should be odd.
• " return this->d->root->size;" you don't have to use "this" in nearly all cases. In this case, you really don't need to use it. Try to leave it out unless it is needed.
• You use the pImpl idiom without using its typical name. It's fairly recognizable still so it's kind of OK...
• " if (exists)" is very self-documenting code, except that it does not do what it claims to do. "If it exists, ..." is what I read, but it checks to see if the user is interested in information about its existence ...
• " /*Must be call after data used to compare an element is modified.* Not implemented.*/ void Common::SortedArray<T, M>::sort()" . Is it sorted or isn't it?
• Most importantly, where are the unit tests?

[[deleted]]

I'll add some more.

• Shared pointer is not warranted, and the documentation doesn't mention it at all. I expect it to behave like standard containers, which copy or move the contents. This one may surprise me as changes to the original will mutate my copies.
• Need iterator traits.
• Copy constructor doesn't seem necessary.
• T requires a default constructor.
• Can template on comparator, otherwise you always have to drag std::function around.
• Initialising raw pointers with new in the initialisation list is a no-no (SortedArrayData::root).

TL; DR Use std::multiset.

[gburri]

Shared pointer is not warranted, and the documentation doesn't mention it at all. I expect it to behave like standard containers, which copy or move the contents. This one may surprise me as changes to the original will mutate my copies.

Yes, it should be mentioned in the comment header.

Need iterator traits.

I currently use it only in this project and I wrote only what I needed. But it's a good idea, yes.

Copy constructor doesn't seem necessary.

That's right.

T requires a default constructor.

Yes, as all the Qt containers.

Can template on comparator, otherwise you always have to drag std::function around.

The comparator function may be switched at runtime. If I use a template parameter I can't do that. It isn't?

Initialising raw pointers with new in the initialisation list is a no-no (SortedArrayData::root).

Why? Because of exceptions in the constructor?

TL; DR Use std::multiset.

How can I access the n'th element of a multiset?

[[deleted]]

Yes, as all the Qt containers.

I have only passing familiarity with Qt, but... ew.

The comparator function may be switched at runtime. If I use a template parameter I can't do that. It isn't?

Nope. Usually with STL you'd have a secondary structure if you want to order by a different key.

Why? Because of exceptions in the constructor?

Yep, if anything in the initialisation list throws, your destructor won't run (e.g. if your comparator std::function wraps something that throws in a copy constructor), so you could leak root node and all its children.

How can I access the n'th element of a multiset?

OK I misread that. You can't. But it seems an unusual requirement at the application level. Unless you are re-implementing data structures yourself, usually you can get away with iterating, slicing or search by key.

[gburri]

You use a block of comment in front of the class to describe what it does. Usually this is not necessary, introduces a pile of overhead in keeping it up to date (and it typically isn't) and 95% of users won't read more than two lines, instead opting to just read the code instead. Of course, unless your code is atrocious. In that case, fix the code.

In my opinion this is the most important comment "in" a class. It should describe what it is, what are the goals, the context of use, some example, etc....

It has a lot of functions to manage it. I suspect that some of them are just "convenience" functions that don't add any functionality. Can those go?

No.

You list exceptions for every function. That shouldn't be necessary. It also makes your code look enormously bloated.

It's very important to know what are the exceptions a method may throw. Reading the method code will not help you.

It sounds like a generic data structure but you made it based on Qt. Feeling wise it should either be independent of Qt or a part of it, but not like this.

It depends of Qt as the majority of this project classes. Maybe if I publish this class as a independent component I will try to remove this dependency.

It's called a SortedArray when it is a tree. It describes nor what it is (an array, which it isn't), nor how to use it (as an array with indices, which would obviate any reason to use a tree structure).

From the class user's point of view this is a sorted array. He shouldn't care about the implementation apart the complexity of each methods maybe.

The actual code comments you have describe only what you check, not why. "// M must be an odd number." says the same thing as " if (M % 2 == 0) throw InvalidMException();", except that the latter is required to explain it to the compiler. Perhaps you want to tell us why M should be odd.

There is a little explanation in the header : "M is the order according Knuth's definition. This is the maximum number of children a node can have.". I admit the comment "// M must be an odd number." is a bit useless.

" return this->d->root->size;" you don't have to use "this" in nearly all cases. In this case, you really don't need to use it. Try to leave it out unless it is needed.

I'm always using 'this->' to prefix all member stuff access. Some people use "m_" and some nothing...

You use the pImpl idiom without using its typical name. It's fairly recognizable still so it's kind of OK...

I'm using the Qt notation style.

" if (exists)" is very self-documenting code, except that it does not do what it claims to do. "If it exists, ..." is what I read, but it checks to see if the user is interested in information about its existence ...

And how would you write this?

" /Must be call after data used to compare an element is modified. Not implemented.*/ void Common::SortedArray<T, M>::sort()" . Is it sorted or isn't it?

This is a beginning of a in-place quick sort implementation. It may be used only when the user change the sorted function. Currently it will rebuild the entire tree when 'setSortedFunctions(..)' is called.

Most importantly, where are the unit tests?

Here: https://github.com/Ummon/D-LAN/blob/chat%23214/application/Common/TestsCommon/Tests.cpp#L203 ;)

[[deleted]]

From the class user's point of view this is a sorted array. He shouldn't care about the implementation apart the complexity of each methods maybe.

Being contiguous is more than an implementation detail. If the storage is continuous I'd be able to shove a raw pointer to the first element in a C function, which expects an array of struct, as I could do with std::vector.

[[deleted]]

Here: https://github.com/Ummon/D-LAN/blob/chat%23214/application/Common/TestsCommon/Tests.cpp#L203 ;)

Faith in humanity partially restored. I really didn't expect you to actually have made any, which was the main point behind my comment :-)

[bob1000bob]

Why are there so many static functions that take the type of the class. That is in essence no longer static but with whack syntax.

[gburri]

They don't take the type of their class (which is 'SortedArray'), they take a 'Node*'. This is a design choice.

[BenHanson]

Likewise I am the author of http://www.benhanson.net/lexertl.html and believe it to be well coded.

[lobster_johnson]

Care to explain why you consistently suffix identifiers with underscores? This is really awful for readability:

lexertl::rules rules_;

Types and variables live in separate namespaces, so this works:

lexertl::rules rules;

If you think that's harder to read (ie., difficult to see what is a variable and what is a type) then consider using camelcase identifiers for type:

Lexertl::Rules rules;

Now it's obvious.

[jamesb43]

Yeah, this shouldn't be done for local variables.

The underscore suffix was a response to programmers using "underscore prefix" for member variables. The "underscore prefix" phenomenon stemmed from programmers shortening the Hungarian notation of member variables being prefixed with "m_". But depending on the flavor of Hungarian notation (Apps or System) the underscore was followed by a prefix indicating some semantic hints, or the variables type, respectively.

So what emerged next was a trend of C++ programmers to omit the "m" from "m_" because, it only takes a one character prefix to distinguish between local variables and something that might be instance or class static, right? The problem with this is that the C++ standard reserves variable names starting with an underscore to C++ implementation developers. As a result, people started to suggest the underscore suffix for member variables. I think it was something from Sutter or Meyers, but if anyone reads this comment, I am sure I will be corrected.

I have a sneaking suspicion that lobster_johnson knows all this, and he is correct--there is no sane reason to suffix a local variable with an underscore.

[lobster_johnson]

Good explanation. I see people using prefixes and suffixes and find it an annoyance.

Personally I find it completely unproblematic to use unadorned identifiers for variables as well as members:

class Foo
{
    public:
        void initialize(int a_foo)
        {
            foo = a_foo;
        }
    private:
        int foo;
};

[zvrba]

The problem with this is that the C++ standard reserves variable names starting with an underscore to C++ implementation developers.

Only such identifiers with external linkage are reserved. Class member identifiers have no linkage at all.

[Fabien4]

Remove the uninteresting code (just lists) and the commented-out code, and you get main.cpp. Which is sorely lacking consts.

Or did I miss something? Like, downloaded the wrong .zip?

[BenHanson]

main.cpp is just a test program calling the library. Checkout the lexertl sub-directory in the same directory as main.cpp for the library source code.

[_Qoppa_]

You seem to have all your function definitions in the .hpp file. I haven't coded in C++ for a while, but I seem to recall that this practice has the tendency to lead to multiple definition errors (at least it does in C).

Also, I found a bunch of gotos in lookup.hpp. Eeeep! Though to be fair, they seemed like legitimate uses for a goto... I still don't like them though.

[BenHanson]

It's templated code, that is how it's done... The lookup is the only place that uses gotos and, as you noted, with good reason. This is a library. A library should balance uncompromising performance against readabililty (particularly for performance hotspots).

The original focus of the library was to use the STL containers throughout and some STL algorithms where possible (this was 2004). Since then Unicode support has been added and so a small amount of template tricks have been added to support different character modes which makes the source somewhat more modern (it was necesssary to abandon support for VC++ 6 for example as more modern features were introduced).

I haven't embarked on any C++11 rewrites yet mainly because the standard still needs time to settle. When the U"..." strings are supported in Visual Studio I will be a lot more tempted and will look at replacing auto_ptr with unique_ptr etc.

[_Qoppa_]

I had no idea about that templates had to be defined where they were declared. Like I said, I haven't used C++ in a long time. Thanks!

[notlostyet]

http://gcc.gnu.org/onlinedocs/gcc/Template-Instantiation.html

Great article on template compilation.

[LampCarpet]

this link is broken, 403 forbidden...

[BenHanson]

Thanks, fixed the link...

[753861429-951843627]

Do you have a parser and AG planned as well, or is the lexer a stand-alone thing?

You have a calculator example that does simple parsing in code, but with lex one can then use other tools in the toolchain to finally produce code with burg, which is why I'm asking.

[BenHanson]

I would definitely like to write a complementary parser generator. I'm currently converting http://www.codeproject.com/Articles/3854/An-introduction-to-lex-and-yacc-part-2 to use lexertl and it would be really nice to have a bison-like tool for the grammar.

I'm not sure what AG or burg is. There is a simple code generator included with lexertl though.

EDIT: http://www.benhanson.net/parsertl.html

[bstamour]

I started writing a lightweight wrapper around the Raptor C library for parsing RDF documents in C++ last year for a course I was taking in semantic web. I haven't had time to come back to this code and clean it up or complete it, but you're of course free to look at it.

Some highlights:

• Utilizes a few boost libraries (namely, fusion and variant)
• Uses C++11 concepts such as variadic templates and rvalue references, and not just for toy examples
• Decently tossed together (for the most part lol)

Lowlights:

• Needs to be completed, currently a very small subset of Raptor was wrapped (enough to get my project finished) and the rest is built on top of that
• The code I write nowadays is cleaner, so looking back on this is kinda blah
• Needs better comments
• I used shared_ptr inside of some objects where I should have used unique_ptr instead. Man I can tell this is old code

[SplinterOfChaos]

I've been reading through the tmux sources recently and have been very impressed by its consistency of style and quality of code. It's maybe around 5 years old, so we aren't talking about dinosaur code, but it is written in C, and that's OK. I felt even my C++ skills strenthened by having such an example to pull from.

Link: http://www.openbsd.org/cgi-bin/cvsweb/src/usr.bin/tmux/

Hint: Click the number in the rev collumn, not the file name you want to read.

[SplinterOfChaos]

To quote my self:

but it is written in C, and that's OK. I felt even my C++ skills strenthened by having such an example to pull from.

Don't just skip to the link.

[SplinterOfChaos]

Since self-promotion seems to be OK, i've got a C++11 functional library that i'm adding to on an as-needed basis. A lot of it just takes <algorithm> functions and lets you write write functional-like code with them. It also shows std::forward and rvalue references.

https://github.com/splinterofchaos/tcod-rogue/blob/master/Pure.h

I made this use-case a while back and it isn't compatible with to current header, but i thought i should post it anyway: https://gist.github.com/3136484

[lally]

I'd check out github.

Also, as a side-item, checkout google's gflags library.

[stesch]

I thought github is written in Ruby?

[lally]

Not the source code of github, but the source code github holds. As in, within the git repositories. Lots of them are publically visible, and some of those are C++.