Here's a practical, minimal guide for using GDB in Ubuntu terminal — from launching to setting breakpoints and navigating your code. 🧰 Step 1: Compile with Debug Symbols Use -g and disable optimizations ( -O0 preferred for debugging): bash Copy Edit g++ -g -O0 -o myprog myprog.cpp 🚀 Step 2: Launch GDB bash Copy Edit gdb ./myprog You'll see a (gdb) prompt. 🎯 Step 3: Set Breakpoints You can set breakpoints in three main ways : ✅ a. At a function gdb Copy Edit (gdb) break main ✅ b. At a specific file and line gdb Copy Edit (gdb) break myprog.cpp:42 ✅ c. At a method in a class gdb Copy Edit (gdb) break MyClass::doSomething If the symbol is mangled (C++), GDB usually demangles automatically, especially if compiled with -g . ▶️ Step 4: Run the Program gdb Copy Edit (gdb) run 🧠Step 5: Navigate Command Meaning next or n Step over current line step or s Step into function call finish Run until current function returns continue or c Continue until...
Q: In emacs/vim I writing c/cpp code n using lsp -clangd as auto complete. Now how to write documentations for my Fns so that when I hover over that Fn used somewhere else, I can see documentations eg say Fn multiply
int multiply(const int &a,const int &b){
return a*b;
}
...
...
int main(){
int a=2,b=3;
int c=multiply(a,b);
return 0;
}
I wn to wirte documentatiosn for multiply fn so that whenever I hover over multiply in main fn it show docs. How to do?
ChatGpt: To write documentation for your functions in C/C++ that will be displayed when you hover over the function in Emacs/Vim with `lsp-clangd`, you can use Doxygen-style comments. Here's how you can do it:
1. **Doxygen Comment Format:**
Write your documentation using Doxygen-style comments above the function definition. These comments can include descriptions of the function, its parameters, and the return value.
2. **Example Documentation:**
Here’s how you can document the `multiply` function:
```cpp
/**
* @brief Multiplies two integers.
*
* This function takes two integers by reference and returns their product.
*
* @param a The first integer to multiply.
* @param b The second integer to multiply.
* @return The product of the two integers.
*/
int multiply(const int &a, const int &b) {
return a * b;
}
```
3. **Hover Documentation:**
When you hover over the `multiply` function in `main`, `lsp-clangd` will display the above documentation.
4. **Enabling Documentation in `lsp-clangd`:**
Make sure that your `clangd` setup is configured to show hover documentation. This is typically enabled by default in `lsp-mode`, but you can customize the behavior by configuring `lsp-ui-doc` or other relevant settings.
This approach will allow you to document your functions in a way that is compatible with both Emacs and Vim when using `lsp-clangd`.
Q: you said Doxygen-style comments. Any other style available (some more styles to write comments)??
chatGpt: Yes, while Doxygen-style comments are the most common and widely supported for C/C++ documentation, there are other styles you can use to write comments that might be recognized by different tools or conventions. Here are a few:
### 1. **Doxygen-Style Comments**
- **Syntax:** `/** ... */`
- **Usage:** Recognized by Doxygen, it’s a common way to document C/C++ code and integrates well with `clangd`.
- **Example:**
```cpp
/**
* @brief Adds two integers.
* @param x The first integer.
* @param y The second integer.
* @return The sum of x and y.
*/
int add(int x, int y) {
return x + y;
}
```
### 2. **Javadoc-Style Comments**
- **Syntax:** `/** ... */`
- **Usage:** Similar to Doxygen but originates from Java. It can also be used in C/C++ with minor differences in tags.
- **Example:**
```cpp
/**
* Adds two integers.
* @param x The first integer.
* @param y The second integer.
* @return The sum of x and y.
*/
int add(int x, int y) {
return x + y;
}
```
### 3. **Qt-Style Comments**
- **Syntax:** `/*! ... */`
- **Usage:** Qt uses this style in its documentation. It’s compatible with Doxygen but with slight differences in emphasis.
- **Example:**
```cpp
/*!
* Adds two integers.
* \param x The first integer.
* \param y The second integer.
* \return The sum of x and y.
*/
int add(int x, int y) {
return x + y;
}
```
### 4. **Single-Line Comments**
- **Syntax:** `///`
- **Usage:** Used for brief documentation of functions or variables. This style is often used in C# and C++, and is supported by Doxygen.
- **Example:**
```cpp
/// Adds two integers and returns the result.
/// @param x The first integer.
/// @param y The second integer.
/// @return The sum of x and y.
int add(int x, int y) {
return x + y;
}
```
### 5. **Multiline Single-Line Comments**
- **Syntax:** `///`
- **Usage:** Allows you to write documentation in a compact way across multiple lines.
- **Example:**
```cpp
/// Adds two integers.
/// This function takes two integers as input
/// and returns their sum.
/// @param x The first integer.
/// @param y The second integer.
/// @return The sum of x and y.
int add(int x, int y) {
return x + y;
}
```
### 6. **In-line Comments**
- **Syntax:** `// ...`
- **Usage:** Used for very brief comments, though not typically used for documentation that tools like `clangd` or Doxygen would parse for hover information.
- **Example:**
```cpp
int add(int x, int y) {
// This function adds two integers and returns the result.
return x + y;
}
```
### 7. **Plain Text Block Comments**
- **Syntax:** `/* ... */`
- **Usage:** General purpose and not usually parsed by documentation tools, but can be used for internal notes or explanations.
- **Example:**
```cpp
/* Adds two integers and returns the result. */
int add(int x, int y) {
return x + y;
}
```
### Summary
- **Doxygen** and **Javadoc-style** comments are most popular for integration with tools that generate documentation and work well with `clangd`.
- **Qt-Style** and **single-line comments** are alternative methods that may be preferred based on project or organization standards.
- You can choose the style that fits your team's practices or the tools you plan to use for generating documentation.
Comments
Post a Comment
If you have any doubts, please let me know.