In C, you can use a constant when declaring an array:
const n = 5; int a[n];
In C++, it would result in compile error "constant expression required". You have to declare it using constexpr:
constexpr int n = 5; int a[n];
However, if you for example want to use the size of a vector to declare an array, you can't use the stack, you have to use the heap:
int* a = new int[myVector.size()]; ... delete[] a;
if (condition)
{
}
else {
}
if (condition) {
} else {
}
#include <iostream>
typedef struct {
int n;
double values[12];
} DATA;
int main() {
DATA data;
std::cout << data.n << ", " << data.values[3] << std::endl;
memset(&data, 0, sizeof(data)); //set all fields to zero
std::cout << data.n << ", " << data.values[3] << std::endl;
std::cout << "Press enter..." << std::endl;
std::cin.get();
}
Consider n nested for loops in Python:
for i_1 in range(n):
for i_2 in range(n):
for i_3 in range(n):
...
for i_n in range(n):
doSomething()
The recursive way would be:
def nForLoops(n, depth = 0):
if depth > n-1: doSomething()
else:
for i in range(n):
nForLoops(n, depth + 1)
A simple iterative function could be written using the observation that doSomething() is called n^n times:
def nForLoops2(n, counter = 0):
while counter < pow(n, n):
counter += 1
doSomething()
TODO: How could we write it iteratively using stack data structure?
Java's Math.round(0.5) and C++'s std::round(0.5) result in the value of 1 while Python 3 round(0.5) results in zero because while Java and C++ use round up, Python 3 uses round half to even.
...exceeding the stack limit is usually considered a segmentation violation, and systems with enough memory management to detect it will send a SIGSEGV [segmentation fault] when it happens.
A typical symptom in a C++ program running on Linux is getting a segmentation fault when entering an innocent function like pow(). To debug, decrease stack usage (e.g. if there is a static array, decrease its size) in the code before the segfault, run your program in debug mode, see if your program continued further than before. Unfortunately, the same program might be working on Windows without problems.
To increase stack size on Linux, use ulimit -s <size_KB>
Wiki style (no signatures/approvals) documentation of complex software projects (lines of code > 10K) has the following benefits:
Sample code showing how to do numeric input and character length checks with a JTable:
Recently I had to deal with a bug in a C project whose root cause was fabs not functioning properly due to missing #include <math>. Finding the root cause involved diving into more than 4 layers of abstractions, it was not fun (!) When run from Visual Studio as a dll project, the code resulted in fabs(10) >= fabs(20) to be true! When I compiled the project with Visual Studio, it gave "warning C4013: 'fabs' undefined; assuming extern returning int". I would normally expect the build to fail in the linking stage. Probably the linker is able to find the fabs but since it was first assumed to be returning int (4 bytes) and fabs returns double (8 bytes), this will result in 4 bytes of the return value being ignored, which can cause funny values. For more about the reason why this behavior is allowed, see my similar trouble with malloc before.
Another interesting fact is that the code was working properly when run from a Simulink s-function. I assume Simulink includes math.h somewhere in its hierarchy. Here is the simplified code:
To prevent Visual Studio from building when 4013 warning exists, go to project Properties - C/C++ - Advanced - Treat Specific Warnings as Errors - Add 4013:
Recently I had a strange bug that caused a previously working C++ simulation to fail. It turned out that a logically unrelated portion of code was corrupting the memory and that corruption resulted in changing of parameter values which resulted in instability. Corruption was due to writing out of index. If that index pointed to a memory location outside the boundaries of my program I would get an access violation. Unfortunately, indices were pointing to my programs memory, therefore I did not get any errors from the operating system and had to pin point the bug by trial and error, i.e. commenting out sections of code until I got a stable state and then uncommenting until I got instability. A simplified version of the code:
Today a program I am writing stopped responding. After some debugging effort, I came across a 3rd party function that limited an input angle to the [-180, 180] degrees interval. It was using a while loop to increment or decrement the angle. Unfortunately, I was passing an uninitialized variable to it and its value was -9.2...e+61. Such a large value would take years for the function to limit. Below is the original function constrainAngleWhile(), together with much better alternatives:
When I check my programs with valgrind for memory leaks I usually get a "still reachable" result, even if there is no memory leak. An example valgrind output:
HEAP SUMMARY:
in use at exit: 72,704 bytes in 1 blocks
total heap usage: 3 allocs, 2 frees, 74,752 bytes allocated
72,704 bytes in 1 blocks are still reachable in loss record 1 of 1
…
LEAK SUMMARY:
definitely lost: 0 bytes in 0 blocks
indirectly lost: 0 bytes in 0 blocks
possibly lost: 0 bytes in 0 blocks
still reachable: 72,704 bytes in 1 blocks
On valgrind's doc it says: "still reachable" means your program is probably ok -- it didn't free some memory it could have. This is quite common and often reasonable.
I wrote a simple program:
#include <iostream>
int main() {
return 0;
}
After I compile and check it with valgrind I get "still reachable". If I comment out the #include line, I don't get "still reachable". I have to research a little bit more.
You can see commit history by clicking the commits link:
git reset --hard <SHA>
Dynamically creating array of object on the heap:
MyClass** objects;
arrSize = 100;
objects = new MyClass*[arrSize]; //Note the '*' before arrSize
for (size_t i = 0; i < arrSize; i++) {
objects[i] = new MyClass();
}
Freeing up heap memory allocated to object array:
for (size_t i = 0; i < arrSize; i++) {
delete objects[i];
}
delete[] objects;
Tip: You can use Visual Studio's Memory Usage diagnostic tool to check heap memory changes which gives clues about memory leaks. To get the function names where memory is allocated but then never released, use valgrind on WSL (Linux) as follows:
valgrind --tool=memcheck --leak-check=yes ./<app name>
You can use Windows 10 and Visual Studio 2022 to generate, debug and analyze Linux binaries:
The following C++ code demonstrates how to safely use an array that is written to by one thread and read from in another thread:
You could define a custom class that derives from JFormattedTextField and use KeyListener to get the raw text that the user is typing:
When you want to run a separate process from C++:
This year's Teknofest has a Vertical Landing Rocket Competition. We can divide the control problem into two:
When developing embedded software for a complex system, it is not advisable to do the development primarily on target hardware because a test that might take a single developer 5 minutes on a PC might take 4 people half a day on target hardware. We are talking about 100x of efficiency difference. To minimize time spent on target hardware, the following six phases of aerospace flight software development might help:
A third party function that I have to use has an input of type char* which the function does not modify. Normally the type should be const char* but the function writer was a novice it seems. I cannot change it to const char* because it is used in other code that such a change would break. I have a variable that needs to be string so that I can use the flexibility of string. In order to send that string variable into the third party function, I cannot just use string.c_str() because the compiler would complain that you cannot send a const char* to a function that expects char*. To remove the "constness", I have to use const_cast<char*> (string.c_str()). Example implementation:
To search for files in
To change Eclipse working folder so that file paths are the same when running project from IDE and when running the binary from terminal, you have to set the working directory (similar to Visual Studio) using the Run Configurations - Arguments - Working Directory: ${workspace_loc:MyProject/Debug}
Note that Eclipse run configurations are saved in <eclipse-workspace>.metadata/.plugins/org.eclipse.debug.core/.launches
To copy files on Linux Eclipse in post-build step:
When working with Eclipse on Windows, some of the system build path variables will have "/" while others have "\" as path separator:
If your code has to behave differently for different C++ versions, you can check the value of __cplusplus directive. It will return the year and month of C++ standard used in your current environment. Examples:
#if __cplusplus < 201100L
The default Visual Studio setup is impractical. Here is my setup for C++:
Note: If you use the same intermediate folder for all configurations, you might get "fatal error C1041: cannot open program database ...vc120.pdb". The solution is to set /FS command line flag.
