Photo by on fireskystudios.com Unsplash 1. Avoid The new Keyword In Java, objects are instantiated using the keyword, so it might be natural to assume that we should use in C++ in the same manner: new new However, unlike in Java, a C++ variable instantiated with is , meaning that you must remember to free the memory after use. new unmanaged This can be done with the keyword. Coming from the Java world, this seems at best inconvenient, and at worst highly error-prone! Why is an extra statement required for the C++ version, when the Java equivalent is so concise? delete In C++, there are multiple ways to instantiate an object and the preferred way to do so is directly onto the stack. When variables are allocated on the stack, they are automatically deleted once they go out of scope. This is very concise, and has great performance characteristics. 2. C++’s is More Powerful Than Java’s const final A common pattern when designing large applications is to make values immutable. This reduces complexity by lowering the number of moving parts an application has. In Java, we can use the keyword to mark a as immutable. However, the data that is being pointed to may change. For example: final reference So to create truly immutable types, Java developers must mark all fields inside of a class as : final In C++ we have the keyword, which is far more powerful. If an instance is marked as , then none of its members may change, even if they are not marked in the class definition! const const const 3. Beware of Stack Slicing! In Java, the semantics of all objects is that they are on the heap (the reality is bit more complicated due to optimizations done by the JVM, but this is a good rudimentary understanding). C++ is very different, because it allows the user to decide if the object should live on the heap or on the stack. Generally speaking, we should prefer the stack. It gives predictable (and fast!) performance, but it has a big limitation in that the size of each variable must be known at compile-time. This is a big problem when using inheritance. In this example we have two classes and , where is a subclass of . Each has a function that returns the class name. A B B A what Given these definitions, what do you think the following will do? If you are coming from the Java world, the answer might surprise you! It turns out that when is cast to type and assigned to , it takes the method of class . y A z what A When a stack-variable is assigned to a super-class in C++, it takes the members and method implementations of that super-class. This is because the size of a variable’s value must not exceed the size of its type. For stack-variables, the compiler just “slices” off the extra information of the sub-class. To prevent this, variables can be instead. A pointer (or always has the same size, regardless of the size of the value being pointed to. pointed to reference ) Quick Aside: value_ptr We released a new smart-pointer called to make it easier to preserve value-semantics on the heap. See: value_ptr _TL;DR_hackernoon.com value_ptr — The Missing C++ Smart-pointer 4. Overload Your Operators! Java does not allow you to define custom value-types and operators similar to and . As a result, vector and matrix implementations can be quite cumbersome! int boolean In C++, we can just overload the operator: + This makes vectors usable with , just like the built-in primitives. + 5. Take Advantage of Compile-time Programming Java’s generics are incredibly simple, and for the most part are only useful for collection types. C++ templates expand the possibilities of compile-time programming considerably, and are in some ways more akin to Java’s annotations. Recall our class from before. If we want to implement a 3-dimensional version in Java, then we need to create a new class: Vector2 In C++, we can make this a parameter of the type, and write generic code that handles all sizes only once! Code is generated at compile-time, so the generic code is no less efficient than the hand-written equivalent. With this generic definition, we can create vectors of any length easily: Templates can even speed up compilation times! See our comparison below: _TL;DR_hackernoon.com Comparing the Compilation Times of C++ Templates and Macros 6. Use auto! Java famously such as (C++), (C#), (Kotlin) or (OCaml). This can make Java code quite verbose, particularly when classes like are in the wild! lacks a variable type-inference keyword auto var val let SimpleBeanFactoryAwareAspectInstanceFactory With C++, the compiler can figure out many types for you, saving you some typing and making code more readable. 7. Be Prepared to Use More Libraries The JVM, for better or for worse, gives you many platform abstractions out-of-the-box. By comparison, C++ is extremely lean. It lacks built-in support for file-systems, networking and graphics. Instead, C++ developers have to leverage libraries for this functionality. A good library will also abstract over platform differences, giving a common set of portable functions, just like Java. Neither approach is strictly better. Java developers benefit from a more unified ecosystem, since everyone is using the same underlying APIs. C++ developers are unburdened by functionality that they do not need, but they also have to make more decisions about what to use, and spend more time integrating it. See: _C++ is an unusual language in that it does not yet have a dominant package manager (we’re working on it!). As a result…_hackernoon.com Approaches to C++ Dependency Management, or Why We Built Buckaroo Buckaroo We created to make it easier to integrate C++ libraries. If you would like try it out, the best place to start is . You can browse the existing packages on or request more over on . Buckaroo the documentation Buckaroo.pm the wishlist
