Is rename added to C++11 as a feature? <\/p>\n\n\n\n
No, it\u00e2\u20ac\u2122s definitely not just an element of C++. In fact, having good names is not a feature of any programming language, as it depends on your style. The compiler can take any names, including single letters and even almost any Unicode character. Thanks to better IDE support and powerful text editors, we can now avoid shortcuts and rely on full and meaningful names. <\/p>\n\n\n\n
And what’s most important is that we can leverage extra refactoring tools, like those from Visual Assist, to fix code with the legacy style. <\/p>\n\n\n\n
Let’s have a look at the following class: <\/p>\n\n\n\n
class PBrush { \npublic: \n\tPBrush(); \n\t~PBrush(); \n\n\tbool Gen(HDC r) { } \n\tbool IsAval() const { return aval; } \n\nprivate: \n\tbool aval; \n\t\n\tHGLOBAL m_hGlobal; \n\tLPBITMAPINFO lpBitmap; \n\tLPBYTE lpBits; \n\tHDC ReferenceDC; \n\t\n\tRGBQUAD m_pal[256]; \n}; <\/pre>\n\n\n\nRead the above code and think about potential naming issues. Is the code clear and descriptive? What would you change? <\/p>\n\n\n\n
Or take a look at the following function, which uses this PBrush<\/strong> objects: <\/p>\n\n\n\nstd::vector<PBrush*> FilterAvalBrushes(const std::vector<PBrush*>& brs) { std::vector<PBrush*> o;\n\tULONG totalBCount = 0; \n\tsize_t totalBitmaps = 0; \n\t\n\tfor (size_t i = 0; i < brs.size(); ++i) { \n\t\tif (brs[i]->IsAval()) { \n\t\t\to.push_back(brs[i]); \n\t\t\t++totalBitmaps; \n\t\t\ttotalBCount += brs[i]->GetByteCount(); \n\t\t} \n\t} \n\t\n\t\/\/ make sure they have some bits ready: \n\tfor (size_t i = 0; i < o.size(); ++i) { \n\t\tif (!o[i]->Bits()) \n\t\t\tLog(\"ERROR, empty bitmap!\"); \n\t} \n\t\n\tLog(\"Byte count %d, total bitmaps %d\", totalBCount, totalBitmaps); return o; \n}<\/pre>\n\n\n\nHow could we improve the code? <\/p>\n\n\n\n
You might be tempted to say that it’s better to leave old code and not touch it since other systems might depend on it. However, adding or changing to better names and keeping it useful to other systems is very simple. In most cases, you can find and replace old names or use Rename from Visual Assist. <\/p>\n\n\n\n
Visual Assist has a powerful feature for renaming objects and making sure the code compiles after this transformation. It was also one of the earliest VA features and enabled using this refactoring capability years before Visual Studio added it. <\/p>\n\n\n\n
You can invoke the rename tool in many situations. <\/p>\n\n\n\n
The simplest way is to hit a key shortcut when your cursor is inside a particular name ( Shift + Alt + R<\/strong> by default). For example, let’s say that I’d like to rename bool aval<\/strong>, so I move my cursor there and invoke the dialog, and then I can see the following window: <\/p>\n\n\n\n![\"\"](\"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/03\/rename_dialog.png?resize=893%2C396&ssl=1\")
<\/a><\/figure>\n\n\n\nAnother option is to write a new name, and then VA will show a handy context menu where you can invoke the rename or see the preview window before making the changes. <\/p>\n\n\n\n
What other things can you do with rename? <\/p>\n\n\n\n
Improve consistency of names. For example, your style guide might suggest adding m_<\/strong> before each nonstatic data member for classes. So you might quickly improve it and add this prefix for classes that don’t share this style. In our example, some names start with m_<\/strong> while others don’t. <\/p>\n\n\n\nIt’s not only variables and functions but also things like enumerations and namespaces. <\/p>\n\n\n\n
But most importantly, what name would be better for aval<\/strong>? Do you prefer m_isAvailable<\/strong> ? or Available ? I’ll leave it as an exercise. <\/p>\n\n\n\n2. Extract Smaller Functions<\/strong> <\/strong><\/p>\n\n\n\nHere’s another example to fix: <\/p>\n\n\n\n
\/\/ number of data components \nswitch ( format ) \n{ \ncase GL_RGB: \ncase GL_BGR_EXT: components = 3; break; \ncase GL_RGBA: \ncase GL_BGRA_EXT: components = 4; break; \ncase GL_LUMINANCE: components = 1; break; \ndefault: components = 1; \n} \n\nGLuint t; \nglGenTextures(1, &t); \n\n\/\/ load data \nHBITMAP hBmp = (HBITMAP)LoadImage(NULL, fname, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION); \nif (hBmp == NULL) \n\treturn 0; \n\t\n\/\/ rest of code... long code<\/pre>\n\n\n\nThe above code is just a part of some longer function that loads, opens a file, loads bytes, and creates an OpenGL texture object with the loaded data. One thing that we might immediately do is to make this function smaller. More compact functions are easier to read and allow for more code reuse. We can see that it has several smaller subtasks, so it would be better to extract them into separate parts. For example, we can implement FormatToComponents<\/strong>: <\/p>\n\n\n\n![\"\"](\"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/03\/extract_method.png?resize=785%2C368&ssl=1\")
<\/a><\/figure>\n\n\n\nAnd when you select this context menu, you’ll get the following dialog: <\/p>\n\n\n\n![\"\"](\"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/03\/extract_method_ui.png?resize=506%2C275&ssl=1\")
<\/a><\/figure>\n\n\n\nAfter some adjustments (for example, we don’t need to take components as input argument), we can prepare the following code: <\/p>\n\n\n\n
int FormatToComponents(GLenum format) { \n\tswitch (format) { \n\tcase GL_RGB: \n\tcase GL_BGR_EXT: return 3; \n\tcase GL_RGBA: \n\tcase GL_BGRA_EXT: return 4; \n\tcase GL_LUMINANCE: return 1; \n\t} \n\treturn 1; \n} <\/pre>\n\n\n\nAnd then call it from our initial function: <\/p>\n\n\n\n
GLuint LoadTextureFromBmp(const char *fname, GLenum format, GLuint filter) { const int components \n\t= FormatToComponents(format); <\/pre>\n\n\n\nThis not only gave us shorter, cleaner code, but also we can now mark our variable as const, which even improves the quality. Additionally, this function might be reused in some other places of the system. <\/p>\n\n\n\n
Here are the general rules for the extraction by VA: <\/p>\n\n\n\n
Symbols available globally, or within the class of the original and new methods, are not passed via a parameter list. <\/p>\n\n\n\n
Symbols used only in the right side of expressions (i.e., not modified) are passed by value. Symbols used in the left side of expressions (i.e., assigned) are passed by reference. Symbols referenced with dot notation within the extracted code (e.g., classes and structs) are always passed by reference. <\/p>\n\n\n\n
When a newly created method assigns a value to only one symbol, that symbol is passed by value and the assignment is done in the original method via return value. <\/p>\n\n\n\n
Symbols local to extracted code become local to the new method; they are not passed.<\/p>\n\n\n\n
3. Improve Function Interfaces<\/strong> <\/strong><\/p>\n\n\n\nLet’s now challenge ourselves with this one: <\/p>\n\n\n\n
bool Init2d(HDC hdcContext, FontMode fm, HFONT hFont, GLuint iWidth, GLuint iHeigth, GLuint iTexture, bool forceBold, bool forceItalic, size_t numGlyphs); <\/pre>\n\n\n\nIt’s a member function in GLFont that is responsible for creating a texture font from a Window font. We can later use this created object to draw text in an OpenGL application. <\/p>\n\n\n\n
Isn’t it worrying that this function takes nine input arguments? <\/p>\n\n\n\n
And here’s an even more suspicious-looking call site: <\/p>\n\n\n\n
glFont.Init2d(const_cast<CGLApp *>(glApp)->GetHdc(), fmBitmap, hFont, iWidth, iHeight, 0, false, false, 256);<\/pre>\n\n\n\nSome books suggest that if you have more than 5… or 7, then it’s some worrying code smell. Such long lists of function arguments are hard to read, and caller sites might easily put them in a wrong order. Another issue is that there are a few boolean parameters, and it’s hard to see what they mean from the caller perspective. <\/p>\n\n\n\n
You can use Change Signature to modify all parts of a signature, including: <\/p>\n\n\n\n
- Method name <\/li>
- Return type <\/li>
- Visibility <\/li>
- Parameter names <\/li>
- Parameter types <\/li>
- Parameter order <\/li>
- Number of parameters <\/li>
- Qualifiers <\/li><\/ul>\n\n\n\n
The plan for our function is to introduce a structure that would hold all parameters. We can do it by simply copying the parameter list and putting it into a structure above the function declaration: <\/p>\n\n\n\n
struct FontCreationParams { \n\tGLuint iWidth; \n\tGLuint iHeigth; \n\tGLuint iTexture { 0 }; \n\tbool forceBold { false}; \n\tbool forceItalic { false}; \n\tsize_t numGlyphs { 256 }; \n}; <\/pre>\n\n\n\nAs you can see, I even assigned some default values. <\/p>\n\n\n\n
And then we can change the signature in two steps: <\/p>\n\n\n\n
1. Add new argument to the function: const FontCreationParams& param with a default value of TODO. <\/p>\n\n\n\n
2. And then, again remove those extra arguments. <\/p>\n\n\n\n
Then you might compile code and fix call sites. <\/p>\n\n\n\n
The final code might look as follows: <\/p>\n\n\n\n
FontCreationParams params; \nparams.iWidth = iWidth; \nparams.iHeigth = iHeight; \nglFont.Init2d(const_cast<CGLApp *>(glApp)->GetHdc(), fmBitmap, hFont, params);<\/pre>\n\n\n\nWith this approach, if you need some more parameters (or you need to alter them), it’s just a matter of modifying the structure, and the function declaration will be the same. <\/p>\n\n\n\n
While you can do such a change manually, Visual Assist makes it much more comfortable and takes care of most of the cases at the call site. So this significantly simplifies and automates the process when you have many function calls. <\/p>\n\n\n\n
So far, we discussed basic principles for code modernization, but how about automation? Can we use extra tools that would tell us what to change in our code? <\/p>\n\n\n\n
Let’s see the fourth point. <\/p>\n\n\n\n
4. Enable Code Inspections<\/strong> <\/strong><\/p>\n\n\n\nSince a few years ago, Visual Assist has come with code Inspections that automatically check your code and pinpoint any issues. <\/p>\n\n\n\n
Code Inspection analyzes C\/C++ for specific code quality issues as you edit. The feature, based on LLVM\/Clang, warns you of issues in your code and if possible, suggests and applies quick fixes. <\/p><\/blockquote>\n\n\n\n
You can enable them via Settings or as shown below: <\/p>\n\n\n\n![\"\"](\"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/03\/enable_code_inspections.png?resize=985%2C714&ssl=1\")
<\/a><\/figure>\n\n\n\nYou can read the full description of Inspections in the excellent documentation website Introduction to Code Inspection and also see our previous article where we dive a bit deeper A Brief Introduction to Clang-Tidy and Its Role in Visual Assist \u00e2\u20ac\u201c Tomato Soup. <\/p>\n\n\n\n
Currently, we have almost 30 code inspections, and the number grows with each revision: List of Code Inspections. <\/p>\n\n\n\n
They range from checking .empty()<\/strong> vs size()<\/strong> , using emplace_back()<\/strong>, nullptr<\/strong> usages, and many more. They can help not only with code modernization but even with finding some performance issues in code. It’s like a small code analysis run on the code. <\/p>\n\n\n\nLet\u00e2\u20ac\u2122s take a look at one related to for loops. <\/p>\n\n\n\n
5. Make For-Loops More Compact<\/strong> <\/strong><\/p>\n\n\n\nOne of the coolest elements of C++11 style comes from using simpler for loops. This is especially important for code that uses containers from the Standard Library. <\/p>\n\n\n\n
For example, before C++11, you had to write: <\/p>\n\n\n\n
std::vector { }... \nfor (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) std::cout << *it << '\\n'; <\/pre>\n\n\n\nNow, this can be simplified with this simple syntax: <\/p>\n\n\n\n
std::vector<int> vec { 1, 2, 3, 4, 5, 6 }; \nfor (const auto& elem : vec) \n\tstd::cout << elem << '\\n';<\/pre>\n\n\n\nWhy not automate this transformation? <\/p>\n\n\n\n
VA identifies places where you can use this modern syntax and then rewrites loops for you. <\/p>\n\n\n\n
Consider this example: <\/p>\n\n\n\n
std::vector<PBrush*> FilterAvalBrushes(const std::vector<PBrush*>& brushes) { \/\/ ... \n\tfor (size_t i = 0; i < brushes.size(); ++i) { \n\t\tif (brushes[i]->IsAval()) { \n\t\t\tout.push_back(brushes[i]); \n\t\t\t++totalBitmaps; \n\t\t} \n\t} \n} <\/pre>\n\n\n\nWhen code inspections are enabled, we can see the following suggestions: <\/p>\n\n\n\n![\"\"](\"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/03\/for_loop_convert.png?resize=819%2C397&ssl=1\")
<\/a><\/figure>\n\n\n\nWhat’s nice about Visual Assist is that it’s very smart and tries to deduce the correct loop syntax. <\/p>\n\n\n\n
For example, when our vector holds pointers, then the converted loop is as follows: <\/p>\n\n\n\n
std::vector<PBrush*> FilterAvalBrushes(const std::vector<PBrush*>& brushes) { \/\/ ... \n\tfor (auto brushe : brushes) { \n\t\tif (brushe->IsAval()) { \n\t\t\tout.push_back(brushe); \n\t\t\t++totalBitmaps; \n\t\t\ttotalBCount += brushe->GetByteCount(); \n\t\t} \n\t} \n} <\/pre>\n\n\n\nBut when we change the type into const std::vector<PBrush><\/strong> (so it holds not pointer but “full” objects), then the loop is as follows: <\/p>\n\n\n\nfor (const auto & brushe : brushes) { \n\tif (brushe.IsAval()) { \n\t\tout.push_back(brushe); \n\t\t++totalBitmaps; \n\t\ttotalBCount += brushe.GetByteCount(); \n\t} \n}<\/pre>\n\n\n\nThe system is smart and avoids situations where you’d copy objects during loop iteration, as it’s more efficient to use references. <\/p>\n\n\n\n
That’s just a taste of what you can automatically do with Visual Assist and its code inspections! <\/p>\n\n\n\n
Summary<\/strong> <\/strong><\/p>\n\n\n\nIn this article, you’ve seen five suggestions on how to check and improve your code. We started with something fundamental but often skipped: naming. Then we made functions smaller and with better interfaces. And at the end, we enabled code inspections so that Visual Assist can automatically identify more things to repair. <\/p>\n\n\n\n
In the last item, we looked at loop transformation, which is available from C++11. Thanks to Visual Assist, we can automate this task and quickly modernize our code to the newer standard <\/p>\n\n\n\n
After such refactoring, we aim to have safer, more readable code. What\u00e2\u20ac\u2122s more, with more expressive code, we can help the compiler to identify potential errors. This is just a start, and stay tuned for the next article where you’ll see other code modernization techniques: override<\/strong> keyword, nullptr<\/strong>, enum class<\/strong>, auto<\/strong> type deduction, and deprecated headers.<\/p>\n\n\n\n![\"\"](\"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/01\/007_banner_wholetomato_resize_emiliano_600x200.png?resize=600%2C200&ssl=1\")
<\/a><\/figure>\n","protected":false},"excerpt":{"rendered":"You probably know that over time our projects seem to get old and legacy. Code written now might look suspicious five years later. With the standardization of C++11 in 2011, developers coined the term Modern…<\/p>\n","protected":false},"author":183830964,"featured_media":1858,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_coblocks_attr":"","_coblocks_dimensions":"","_coblocks_responsive_height":"","_coblocks_accordion_ie_support":"","_jetpack_newsletter_access":"","_jetpack_newsletter_tier_id":0,"footnotes":""},"categories":[672],"tags":[910314,2426,54971,4458826,621688,885520,78684782,318578,1788,12004844],"class_list":["post-1842","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tips-and-tricks","tag-analyze","tag-c","tag-c11","tag-code-inspection","tag-extract","tag-for-loop","tag-modern-c","tag-rename","tag-tips","tag-visual-assist"],"aioseo_notices":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/03\/enablecodedevice.jpg?fit=1920%2C1080&ssl=1","jetpack_likes_enabled":true,"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/pfhqii-tI","amp_enabled":true,"_links":{"self":[{"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/posts\/1842","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/users\/183830964"}],"replies":[{"embeddable":true,"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/comments?post=1842"}],"version-history":[{"count":18,"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/posts\/1842\/revisions"}],"predecessor-version":[{"id":1872,"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/posts\/1842\/revisions\/1872"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/media\/1858"}],"wp:attachment":[{"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/media?parent=1842"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/categories?post=1842"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/stage.wholetomato.com\/blog\/wp-json\/wp\/v2\/tags?post=1842"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![\"\"](\"https:\/\/i0.wp.com\/stage.wholetomato.com\/blog\/wp-content\/uploads\/2021\/03\/rename_dialog.png?ssl=1\")
<\/a><\/figure>\n\n\n\n