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:
| /* | |
| * Table with numeric input and length checks. | |
| * Şamil Korkmaz, June 2022 | |
| */ | |
| package tablewithnumericinput; | |
| import java.awt.Color; | |
| import java.awt.event.KeyEvent; | |
| import java.awt.event.KeyListener; | |
| import javax.swing.DefaultCellEditor; | |
| import javax.swing.InputVerifier; | |
| import javax.swing.JButton; | |
| import javax.swing.JComponent; | |
| import javax.swing.JFrame; | |
| import javax.swing.JOptionPane; | |
| import javax.swing.JScrollPane; | |
| import javax.swing.JTable; | |
| import javax.swing.JTextField; | |
| import javax.swing.table.DefaultTableModel; | |
| public class TableWithNumericInput { | |
| static private JTextField jtfForNumericFields; | |
| static class MyKeyListener implements KeyListener { | |
| @Override | |
| public void keyTyped(KeyEvent ke) { | |
| if (ke.getKeyCode() != KeyEvent.VK_BACK_SPACE && ke.getKeyCode() != KeyEvent.VK_DELETE) { | |
| char c = ke.getKeyChar(); | |
| System.out.println("c = " + c); | |
| System.out.println("Inside keyTyped()"); | |
| if (ke.getSource() instanceof JTextField) { //When user first double clicks on table and then presses a key, jtf will be the key event source | |
| System.out.println("Key event source is text field"); | |
| } else if (ke.getSource() instanceof JTable) { //When table has focus but user has not double clicked on it, table will be the key event source | |
| System.out.println("Key event source is table"); | |
| } | |
| try { | |
| Double.parseDouble(jtfForNumericFields.getText() + c); //getText() returns text before keypress, we have to add pressed key char to get full text | |
| if (c == 'd' || c == 'f') { //parseDouble accepts 'd' and 'f' at the end of text | |
| ke.consume(); //ignore key press | |
| } else { | |
| if (!jtfForNumericFields.getInputVerifier().verify(jtfForNumericFields)) { //check if text exceeds max nb of characters | |
| ke.consume(); //ignore key press | |
| } | |
| } | |
| } catch (NumberFormatException e) { //text is not a number | |
| ke.consume(); //ignore key press | |
| } | |
| } | |
| } | |
| @Override | |
| public void keyPressed(KeyEvent ke) { | |
| } | |
| @Override | |
| public void keyReleased(KeyEvent ke) { | |
| } | |
| } | |
| static class MyTable extends JTable { | |
| public MyTable() { | |
| putClientProperty("terminateEditOnFocusLost", true); //To make sure that setValue() is called when user clicks on another component, e.g. a button. | |
| } | |
| @Override | |
| public void setValueAt(Object value, int iRow, int iColumn) { | |
| if (value != null && ((String)value).length() > 0) { | |
| if (iColumn > 0) { | |
| double doubleValue = Double.parseDouble((String)value); | |
| super.setValueAt(doubleValue, iRow, iColumn); | |
| } else { | |
| super.setValueAt(value, iRow, iColumn); | |
| } | |
| } | |
| } | |
| } | |
| public static void main(String[] args) { | |
| JFrame jf = new JFrame(); | |
| jf.setTitle("Table with numeric input checks"); | |
| jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); | |
| jf.getContentPane().setLayout(new javax.swing.BoxLayout(jf.getContentPane(), javax.swing.BoxLayout.PAGE_AXIS)); | |
| JTable jt = new MyTable(); | |
| jf.add(new JScrollPane(jt)); //to show table column headers | |
| JButton jb = new JButton("OK"); | |
| jb.addActionListener((java.awt.event.ActionEvent evt) -> { | |
| JOptionPane.showMessageDialog(jf, "Table contents: " + jt.getValueAt(0, 0) + ", " + jt.getValueAt(0, 1)); | |
| }); | |
| jf.add(jb); | |
| jf.setBounds(100, 100, 400, 150); | |
| jt.setBorder(javax.swing.BorderFactory.createLineBorder(Color.BLACK)); | |
| DefaultTableModel model = new DefaultTableModel() { | |
| Class[] types = new Class[]{String.class, Double.class}; | |
| @Override | |
| public Class getColumnClass(int iCol) { | |
| return types[iCol]; | |
| } | |
| }; | |
| jt.setModel(model); | |
| model.addColumn("ID"); | |
| model.addColumn("Double Value"); | |
| model.addRow(new Object[]{}); | |
| final int PANEL_WIDTH = 200; | |
| final int TABLE_HEIGHT = 3 * jt.getRowHeight(); | |
| jt.setBounds(0, jt.getRowHeight(), PANEL_WIDTH, TABLE_HEIGHT); | |
| jt.getTableHeader().setBounds(0, 0, PANEL_WIDTH, jt.getRowHeight()); | |
| jtfForNumericFields = new JTextField(); | |
| jtfForNumericFields.setInputVerifier(new InputVerifier() { | |
| @Override | |
| public boolean verify(JComponent jc) { | |
| JTextField jtf = (JTextField) jc; | |
| String text = jtf.getText(); | |
| System.out.println("Text: " + text); | |
| final int maxLength = 9; | |
| if (text.length() > (maxLength - 1)) { | |
| System.out.println("length > " + maxLength); | |
| return false; | |
| } | |
| return true; | |
| } | |
| }); | |
| //Note that we have to add key listener to both table and text field because when | |
| //table column 1 has focus and user presses a key, editing will start and table will catch | |
| //key events. If user double click on column 1, then text field will catch key events: | |
| jt.addKeyListener(new MyKeyListener()); | |
| jtfForNumericFields.addKeyListener(new MyKeyListener()); | |
| //Use numeric text field as editor for column 1 (second column): | |
| jt.getColumnModel().getColumn(1).setCellEditor(new DefaultCellEditor(jtfForNumericFields)); | |
| jf.setVisible(true); | |
| } | |
| } |
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:
| //When the #include <math.h> line below is commented out, code will build with "warning C4013: 'fabs' undefined; assuming extern returning int" message. | |
| //It will also run although fabs is not defined. In that case, fabs() will always the same number, it can be anything, e.g. 8, 256. | |
| //This will cause the fabs(10) >= fabs(20) line to be true. | |
| //In Visual Studio, to prevent build when there is a 4013 warning, go to project Properties - C/C++ - Advanced - Treat Specific Warnings as Errors - Add 4013 | |
| //Şamil Korkmaz, June 2022 | |
| #include <stdio.h> | |
| //#include <math.h> | |
| int main() { | |
| fabs(10) >= fabs(20) ? printf("true\n") : printf("false\n"); | |
| double a = fabs(10); | |
| double b = fabs(20); | |
| double c; | |
| printf("a = %1.1f, b = %1.1f\n", a, b); | |
| printf("Press enter...\n"); | |
| getchar(); | |
| } |
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:
| #include <stdexcept> | |
| void getDoubleVectorFromName(string name, double vec[MAX_FILE_NAME_LENGTH]) { | |
| if (name.length() > MAX_FILE_NAME_LENGTH) { //Without this check, if string is unitialized, its length might be more than MAX_FILE_NAME_LENGTH, which might result in out of bounds writing below, leading to undefined behaviour. | |
| char msg[255]; | |
| sprintf(msg, "ERROR in %s, %s: name.length() (%llu) > MAX_FILE_NAME_LENGTH (%d)\n", __FILE__, __FUNCTION__, name.length(), MAX_FILE_NAME_LENGTH); | |
| printf(msg); | |
| throw std::invalid_argument(msg); | |
| } | |
| for (size_t i = 0; i < name.length(); i++) { | |
| if (name[i] < 0) { | |
| char msg[255]; | |
| sprintf(msg, "ERROR in %s, %s: Not a valid name character code: %d at index %llu\n", __FILE__, __FUNCTION__, name[i], i); | |
| printf(msg); | |
| throw std::invalid_argument(msg); | |
| } | |
| vec[i] = name[i]; | |
| } | |
| for (size_t i = name.length(); i < MAX_FILE_NAME_LENGTH; i++) { | |
| vec[i] = 0; | |
| } | |
| } |
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:
| //Demonstrate different methods to limit an angle to the [-180, 180] degree interval. | |
| //To quickly test, paste code to https://www.onlinegdb.com/online_c++_compiler | |
| //Şamil Korkmaz, May 2022 | |
| #include <iostream> | |
| #include <math.h> | |
| using namespace std; | |
| //https://stackoverflow.com/a/11498248/51358 | |
| double constrainAngleMod(double x) { | |
| x = fmod(x + 180,360); | |
| if (x < 0) x += 360; | |
| return x - 180; | |
| } | |
| double constrainAngleWhile(double x) { | |
| double limitedX = x; | |
| //Note that the while loops below will take a long time if the input x is a large value. | |
| //For example, an unitialized variable can have a value like -9.2...e+61 which would take years! | |
| while (limitedX < -180) limitedX += 360; | |
| while (limitedX > 180) limitedX -= 360; | |
| return limitedX; | |
| } | |
| int main() { | |
| cout << "Calculating...\n"; | |
| //Using remainder(): https://stackoverflow.com/a/11503585/51358 | |
| cout << remainder(180, 360) << ", " << constrainAngleWhile(180) << endl; | |
| cout << remainder(181, 360) << ", " << constrainAngleWhile(181) << endl; | |
| cout << remainder(-181, 360) << ", "<< constrainAngleWhile(-181) << endl; | |
| cout << remainder(-359, 360) << ", "<< constrainAngleWhile(-359) << endl; | |
| cout << remainder(359, 360) << ", "<< constrainAngleWhile(359) << endl; | |
| cout << remainder(-360, 360) << ", "<< constrainAngleWhile(-360) << endl; | |
| cout << remainder(360, 360) << ", "<< constrainAngleWhile(360) << endl; | |
| double angle_deg = 1e12; | |
| cout << remainder(angle_deg, 360) << ", " << constrainAngleMod(angle_deg) << endl; | |
| cout << constrainAngleWhile(angle_deg) << endl; | |
| cout << "Finished.\n"; | |
| return 0; | |
| } |
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:
| //How to safely use an array that is written to by one thread and read from in another thread. | |
| //Requires C++11 or later. | |
| //Şamil Korkmaz, 10.03.2022, public domain. | |
| #include <chrono> | |
| #include <iostream> | |
| #include <thread> | |
| #include <mutex> | |
| std::mutex mx; | |
| std::condition_variable cv; | |
| const size_t arraySize = 1000; | |
| double arr[arraySize]; | |
| void writeArray() { | |
| size_t counter = 0; | |
| while (1) { | |
| auto currentTime = std::chrono::steady_clock::now(); | |
| auto nextTime = currentTime + std::chrono::milliseconds(1); | |
| //printf("writeArray, counter = %d\n", counter); | |
| { //critical section | |
| std::unique_lock<std::mutex> lock(mx); | |
| for (size_t i = 0; i < arraySize; i++) { | |
| arr[i] = counter; | |
| } | |
| } //lock is automatically released here | |
| cv.notify_all(); //let other threads to get lock | |
| counter++; | |
| std::this_thread::sleep_until(nextTime); | |
| } | |
| } | |
| void readArray() { | |
| while (1) { | |
| auto currentTime = std::chrono::steady_clock::now(); | |
| auto nextTime = currentTime + std::chrono::milliseconds(1); | |
| double arrStart; | |
| double arrEnd; | |
| { //critical section | |
| std::unique_lock<std::mutex> lock(mx); | |
| cv.wait(lock); //wait for writeArray to finish | |
| arrStart = arr[0]; | |
| arrEnd = arr[arraySize - 1]; | |
| } //lock is automatically released here | |
| auto arrDiff = arrEnd - arrStart; | |
| printf("* readArray, arrStart = %1.0f, arrEnd = %1.0f, arrDiff = %1.1f\n", arrStart, arrEnd, arrDiff); | |
| if (arrDiff < 0) //happens when the end of array is lagging behing beginning of array. You trigger it by commenting out the lock line above | |
| { | |
| printf("End of array lagging behind beginning of array! arrDiff = %1.1f < 0\n", arrDiff); | |
| std::cout << "Press enter..." << std::endl; | |
| std::cin.get(); | |
| exit(1); | |
| } | |
| std::this_thread::sleep_until(nextTime); | |
| } | |
| } | |
| int main() { | |
| std::thread worker1(writeArray); | |
| std::thread worker2(readArray); | |
| worker1.join(); | |
| worker2.join(); | |
| std::cout << "Press enter..." << std::endl; | |
| std::cin.get(); | |
| } |
You could define a custom class that derives from JFormattedTextField and use KeyListener to get the raw text that the user is typing:
| public class MyFormattedTextField extends JFormattedTextField { | |
| private String rawText; | |
| private class MyKeyListener implements KeyListener { | |
| ... | |
| @Override | |
| public void keyTyped(KeyEvent e) { | |
| rawText = getText(); | |
| } | |
| } | |
| public MyFormattedTextField() { | |
| addKeyListener(new MyKeyListener()); | |
| } | |
| public String getRawText() { | |
| return rawText; | |
| } | |
| } |
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:
| //Demonstrates how a thread can be started and stopped | |
| #include <iostream> | |
| #include <thread> | |
| #include <chrono> | |
| bool isRunning = false; | |
| class MyClass { | |
| public: | |
| ~MyClass() { | |
| if (worker != nullptr) { | |
| isRunning = false; | |
| worker->join(); | |
| delete worker; | |
| std::cout << "worker deleted" << std::endl; | |
| } | |
| } | |
| static void Run(double duration_s) { | |
| while (isRunning) { | |
| std::cout << "isRunning" << std::endl; | |
| auto startTime = std::chrono::steady_clock::now(); | |
| auto endTime = startTime + std::chrono::duration<double>(duration_s); | |
| std::this_thread::sleep_until(endTime); | |
| } | |
| std::cout << "thread ended" << std::endl; | |
| } | |
| void Start(double duration_s) { | |
| isRunning = true; | |
| worker = new std::thread(Run, duration_s); | |
| } | |
| void Stop() { | |
| isRunning = false; | |
| } | |
| private: | |
| std::thread* worker; | |
| }; | |
| int main() { | |
| MyClass m; | |
| m.Start(1); | |
| auto startTime = std::chrono::steady_clock::now(); | |
| auto endTime = startTime + std::chrono::duration<double>(3); | |
| std::this_thread::sleep_until(endTime); | |
| m.Stop(); | |
| std::cout << "Main ended. Press enter...\n"; | |
| std::cin.get(); | |
| } | |
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.
