{"id":34219,"date":"2024-05-30T19:15:25","date_gmt":"2024-05-30T19:15:25","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=34219"},"modified":"2024-06-04T19:17:34","modified_gmt":"2024-06-04T19:17:34","slug":"c-refactoring-tools-in-visual-studio","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/c-refactoring-tools-in-visual-studio\/","title":{"rendered":"C++ Refactoring tools in Visual Studio"},"content":{"rendered":"

Code refactoring is the process of restructuring existing code, while its outward functionality remains unchanged. By refactoring, you can simplify complex code structures, reduce code redundancy, and enhance code reusability. Visual Studio offers many tools to help refactor your C++ code. This article will delve into these tools, using the <\/span>bullet3<\/span><\/a> open-source code as an example.<\/span>\u00a0<\/span><\/p>\n

Rename<\/span><\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

The renaming tool is useful when changing a symbol name that appears in multiple locations within your code. Manual renaming can lead to errors if one or more instances of your function or variable are overlooked. However, the renaming tool ensures all instances are renamed accurately and seamlessly.<\/span>\u00a0<\/span><\/p>\n

Consider the <\/span>ExampleEntryPhysicsServer<\/code> struct in the \u2018InProcessExampleBrowser.cpp\u2019 file. Suppose we want to rename the <\/span>m_menuLevel<\/code> variable to<\/span> m_menuHierarchyLevel<\/code> to make it more descriptive for clarity. Visual Studio\u2019s <\/span>Rename <\/span><\/b>refactoring tool can accomplish this, by right-clicking on the variable name, selecting Rename, and then typing the new name. Visual Studio will automatically update all instances of <\/span>m_menuLevel<\/code> to<\/span> m_menuHierarchyLevel<\/code>, eliminating the need for manual renaming.<\/span><\/p>\n

\"Gif<\/p>\n

AI-Powered Rename Suggestions<\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

GitHub Copilot<\/span><\/a>‘ s AI-Powered Rename Suggestions is a new feature in Visual Studio 2022 that generates dynamic name suggestions for any C++ identifier, aiding in achieving a balance between descriptiveness and brevity. This allows you to dedicate your efforts towards evaluating the proposed names, rather than generating new ones.<\/span>\u00a0<\/span><\/p>\n

You can make this feature visible by selecting \u201cEnable rename suggestions\u201d <\/span>Tools <\/span><\/b>> <\/span>Options <\/span><\/b>><\/span> GitHub<\/span><\/b> > <\/span>Copilot chat<\/span><\/b> > <\/span>Preview features<\/span><\/b>.\u00a0<\/span>\u00a0<\/span><\/p>\n

Let\u2019s use the AI-Powered Rename Suggestions to rename<\/span> m_name<\/code> to a more descriptive one. First, right-click on the variable and choose Rename. In the Rename window that appears, click on the new sparkle icon to generate name suggestions. Copilot chat will then offer suggestions based on how the identifier is used and the naming rules in your code. Let\u2019s select <\/span>m_entryName<\/code>, and then preview and apply the change.<\/span><\/p>\n

\"Image<\/a><\/p>\n

Change Signature<\/span><\/span><\/a>\u00a0<\/span><\/span>\u00a0<\/span><\/h3>\n

The <\/span><\/span>Change Signature<\/span><\/span><\/strong> feature helps you <\/span>modify<\/span> a function\u2019s parameters in a safe and efficient manner<\/span>.<\/span> When<\/span> we want to provide <\/span>a <\/span>new parameter for a <\/span>description<\/span> to the first instance of <\/span><\/span>ExampleEntryPhysicsServer<\/code>\u00a0<\/span>constructor<\/span>, <\/span>we will<\/span> r<\/span>ight-click on <\/span>its <\/span>name and select the <\/span>\u2018Quick Actions and <\/span>Refactorings<\/span>…\u2019 option or use <\/span>the Ctrl<\/span>+. keyboard shortcut. Select the <\/span><\/span>Change Signature<\/span><\/span><\/strong> option to open a new window. Here, you can add, remove, or reorder parameters. <\/span>We\u2019ll<\/span> add a <\/span>constant string pointe<\/span>r <\/span>m_description<\/code><\/span>,<\/span> by typing the type and name. Visual Studio will automatically update all function calls accordingly.<\/span><\/span>\u00a0<\/span><\/p>\n

\"Gif<\/p>\n

Similar to<\/span> renaming, changing functions one by one can result in errors and this tool can do it automatically to <\/span>eliminate<\/span> those errors.<\/span><\/span><\/p>\n

Extract Function<\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

Extract Function<\/span><\/b> is a great way to break down complex functions into smaller, more manageable parts, and allows for potential reusability of a block of code if similar functionality is needed elsewhere in the program. In this code, let\u2019s extract the block of code from the <\/span>ExampleBrowserThreadFunc<\/code> function that calculates and updates <\/span>deltaTimeInSeconds<\/code> and then decides whether to update graphics or reset the clock based on deltaTimeInSeconds<\/code>. This block of code is a logical unit that performs a specific task, so it makes sense to extract it into a separate function. <\/span>\u00a0<\/span><\/p>\n

To do so, select the block of code that we want to extract, then right-click on the editor, then select the \u2018Quick Actions and Refactorings…\u2019 option. This will display the <\/span>Extract Function<\/span><\/b> tool. Choosing that option will open a new window that will allow you to choose a new function name and placement. A new function will be set up at the chosen location, with a matching prototype in the header file. The initial code will be revised to invoke this function.<\/span>\u00a0<\/span><\/p>\n

\"Gif<\/a><\/p>\n

This helps to avoid code duplication and makes your code easier to read and <\/span>maintain<\/span>.<\/span>\u00a0<\/span><\/span>\u00a0<\/span><\/p>\n

Implement Pure Virtuals<\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

When dealing with a base class that has pure virtual functions, Visual Studio can help implement these functions in all derived classes. In this source code, all pure virtual functions of the base class are implemented. However, for the sake of an example, I modified the <\/span>CommonRigidBodyBase<\/code> struct to include a pure virtual function <\/span>virtual void somePureVirtualFunction () = 0;<\/code>. Now we will use <\/span>Implement Pure Virtuals<\/span><\/b> to provide an implementation for <\/span>somePureVirtualFunction ()<\/code> in the <\/span>BasicExample<\/code> class.<\/span>\u00a0<\/span><\/p>\n

First, right-click on the derived class and select the \u2018Quick Actions and Refactorings…\u2019 option from the context menu or use Ctrl+. keyboard shortcut. Then select the Implement all Pure Virtuals for class <\/span>BasicExample<\/code> option, and the pure virtual method will be added automatically.<\/span>\u00a0<\/span><\/p>\n

\"Gif<\/a><\/p>\n

This saves more time especially if you have a lot of virtual functions, because instead of doing it one by one, this tool will implement all pure virtual functions automatically.<\/span><\/span>\u00a0<\/span><\/p>\n

Create Declaration \/ Definition<\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

This feature enables you to easily generate a function\u2019s declaration or definition. Let\u2019s consider adding a new function, <\/span>printExampleDetails<\/code> that takes a pointer to an <\/span>ExampleEntriesPhysicsServer<\/code> object and prints the details of all the examples registered in the server. We can use <\/span>Create Declaration\/Definition<\/span><\/b> tool, to seamlessly declare it.\u00a0<\/span>\u00a0<\/span><\/p>\n

Select the block of code, then right-click on the editor, then select the \u2019Quick Actions and Refactorings…\u2019 option from the context menu or use Ctrl+. keyboard shortcut. This will display the Create Declaration\/Definition<\/strong>\u00a0option, which will automatically create the declaration for that function. <\/span>\u00a0<\/span><\/p>\n

\"Gif<\/p>\n

Move Definition Location<\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

Now that we have seen how to declare a function, we can move a function\u2019s definition to its corresponding header file. In the \u2018ExampleEntries.cpp\u2019 file, we have a\u00a0<\/span><\/span>ExampleEntriesAll::registerExampleEntry<\/code>\u00a0function. For code reusability, <\/span>let\u2019s<\/span> move the definition of this function to a header file.<\/span><\/span>\u00a0<\/span><\/p>\n

To move function location, right-click on the function, then select the \u2018Quick Actions and Refactorings…\u2019 option from the context menu or use Ctrl+. keyboard shortcut. Then choose the <\/span>Move Definition Location<\/span><\/b> option, to move the function to the corresponding header file.<\/span>\u00a0<\/span><\/p>\n

\"Gif<\/a><\/p>\n

This feature can be very useful when you want to organize your code by moving function definitions to appropriate header files without having to do it manually.<\/span>\u00a0<\/span><\/p>\n

Convert to Raw String Literal<\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

Next, let\u2019s look at a string with special characters or escape sequences. For example, if you have a string\u00a0Torus (Shape Match)<\/code>\u00a0and you want to add quotation marks around\u00a0Torus<\/code>, you would normally need to use escape characters, like this:\u00a0\\\"Torus\\\" (Shape Match)<\/code>. However, this can make the string harder to read, especially if there are many special characters. To solve this problem, we can convert them to raw string literals by prefixing the string with\u00a0R<\/code>\u00a0and enclosing it in parentheses, like this:\u00a0R\"(\"Torus\" (Shape Match))\"<\/code>. This tells the program to interpret all characters within the parentheses as literal characters, not special characters.<\/p>\n

To convert to Raw String Literal<\/strong>, right-click on the string and then select the \u2018Quick Actions and Refactorings\u2026\u2019 option from the context menu or use the Ctrl+. keyboard shortcut. Then, selecting the \u2018Convert to Raw String Literal\u2019 option will complete the process. Visual Studio will preserve the exact content of the string.<\/p>\n

\"Gif<\/a><\/p>\n

Convert Macros to Constexpr<\/span><\/span><\/span><\/a>\u00a0<\/span><\/h3>\n

Macros can be challenging to read and debug but converting them to constexpr functions can enhance code readability and maintainability. This feature identifies macros that can be converted to constexpr, and then offers a quick way to convert them to modern C++ constexpr expressions.<\/span>\u00a0<\/span><\/p>\n

To convert <\/span>#define ARRAY_SIZE_Y 5<\/code> to a constexpr, you can hover over the suggestion indicator (…) below the macro or select the macro and then chose \u2019Quick Actions and Refactorings…\u2019 option from the context menu (Ctrl+. keyboard shortcut). This will display the <\/span>Convert Macros to Constexpr<\/span><\/b> option, which will complete the conversion to <\/span>constexpr auto ARRAY_SIZE_Y = 5;<\/code>.<\/span>\u00a0<\/span><\/p>\n

\"Gif<\/a><\/p>\n

This feature can process constants and basic expressions contained in function-like macros. Due to performance optimization, some macros may not display the \u2018\u2026\u2019 indicator, however, the conversion option remains readily available in the lightbulb menu. <\/span>To configure <\/span>Convert Macros to Constexpr<\/span><\/b>, navigate <\/span>Tools <\/span><\/b>> <\/span>Options <\/span><\/b>> <\/span>Text Editor<\/span><\/b> > <\/span>C\/C++<\/span><\/b> > <\/span>View <\/span><\/b>> <\/span>Macros Convertible to constexpr<\/span><\/b>.<\/span>\u00a0<\/span><\/p>\n

Convert Macros to Constexpr <\/span><\/b>is a feature within our fix-it capabilities. In our forthcoming blog post, we will delve into additional fix-it features that are currently available in Visual Studio.<\/span><\/p>\n

GitHub Copilot for Refactoring<\/span><\/span><\/a>\u00a0<\/span>\u00a0<\/span><\/h3>\n

GitHub Copilot<\/span><\/a>, an AI-powered coding assistant, can help C++ developers refactor their code. It offers a streamlined process for refactoring, making it an efficient and effective tool for code optimization.<\/span>\u00a0<\/span><\/p>\n

To utilize <\/span>GitHub Copilot for refactoring<\/span><\/b>, begin by identifying the segment of code you wish to refactor. This could be a function, a class, or even a single line of code. Once identified, right-click on the selected code and request assistance from Copilot to refactor it. The command can be tailored to your specific needs. Upon generating a suggestion for the refactoring, it\u2019s crucial to review this carefully. Make any necessary adjustments to ensure it aligns with your coding standards and project requirements. Once you\u2019re satisfied with the proposed refactoring, proceed to implement the changes in your code.<\/span>\u00a0<\/span><\/p>\n

For instance, suppose you\u2019re working with a complex function in C++, like <\/span>btCreateInProcessExampleBrowser<\/code> in \u2018InProcessExampleBrowser.cpp\u2019. To simplify it, you\u2019d highlight the function and ask GitHub Copilot for a simplification. Copilot suggested using auto for type inference, nullptr instead of 0, static_cast for safer type conversion, and limiting the scope of loop variables. These changes improve readability, safety, and maintainability. You can select preview, to compare and review the differences between the original and proposed code. If you\u2019re satisfied with the changes, you can accept them to incorporate the refactored code directly into your existing codebase.<\/span><\/p>\n

\"Gif<\/a><\/p>\n

Send us your feedback<\/span><\/span>\u00a0<\/span><\/h3>\n

We encourage you to continue exploring the C++ refactoring features in <\/span>Visual Studio<\/span><\/a>. Your insights and experiences are invaluable to us, therefore, please share your feedback and suggestions in the comments section below or through the <\/span>Developer Community<\/span><\/a>. You can also reach out to us on Twitter (<\/span>@VisualC<\/span><\/a>) or via email at <\/span>visualcpp@microsoft.com<\/span><\/a>. We are always eager to hear from you.<\/span>\u00a0<\/span><\/p>\n

Furthermore, if there are additional refactoring features that you find necessary or would frequently use, we would greatly appreciate your input. Your suggestions help us understand your needs better and continually improve our product.<\/span>\u00a0<\/span><\/p>\n

 <\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

Code refactoring is the process of restructuring existing code, while its outward functionality remains unchanged. By refactoring, you can simplify complex code structures, reduce code redundancy, and enhance code reusability. Visual Studio offers many tools to help refactor your C++ code. This article will delve into these tools, using the bullet3 open-source code as an […]<\/p>\n","protected":false},"author":96741,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-34219","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cplusplus"],"acf":[],"blog_post_summary":"

Code refactoring is the process of restructuring existing code, while its outward functionality remains unchanged. By refactoring, you can simplify complex code structures, reduce code redundancy, and enhance code reusability. Visual Studio offers many tools to help refactor your C++ code. This article will delve into these tools, using the bullet3 open-source code as an […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/34219","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/96741"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=34219"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/34219\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=34219"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=34219"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=34219"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}