REPIT | A Device-Only Data-Sparing Repartitioning Tool For Android | Android library

In your nested for loop, the for statements should iterate over your elements in row and columns (so starting with row[0] and columns[0], then row[1] and columns[1]).

What it's doing right now is iterating over every element in letters, so it breaks when i = 0 and j = 2 - this doesn't exist in row and columns, but is a valid coordinate in letters.

What you want is something like this:

This code works fine for me

HTML:

You have to use sid and id to identify the right row

try in this way

Is this what you want?

you can iterate the list then concatenate it with fixed string 'node_' and add in the new list.

my struct has a lot of data within it (around 50 strings) and copying it over sounds inefficient and a hassle.

...

void printVerbs(verbType verbArray[VERBS], int count);

First, start using C++ containers like std::vector or QVector instead of raw C arrays. The C++ container classes are much easier to manage and debug.

Then, you can cheaply pass arrays around by const reference:

void printVerbs(const QVector &verbArray);

Note: You don't need to pass count! The vector knows how many elements it contains.

This achieves 2 things:

• The reference part ensures that your data is not copied during the function call, because the function is referencing the data that already exists
• The const part ensures that the function cannot accidentally modify your existing data.

QVector is implicitly-shared (also called "copy-on-write"): https://doc.qt.io/qt-5/implicit-sharing.html This means you can pass a copy of QVector from your MainWindow into your TenseSelectionDialog and even store a copy as a member variable in TenseSelectionDialog. As long as neither copy is modified, both vectors will share the same data internally.

Alternatively, if you guarantee that MainWindow will always outlive TenseSelectionDialog, then you can have TenseSelectionDialog store a pointer or reference to MainWindow's member variable.

I also don't know whether I should make it an array of pointers to structs if that'd be the way to go.

Using an array-of-pointers is most useful if:

• Your array will get modified or copied frequently.
  • Inserting or removing elements can cause the array contents to be moved in memory.
  • It is cheaper to move/copy pointers than large structs.
• Your array will be huge.
  • Data in an array is stored in a contiguous memory block, given by N * sizeof where N is the number of elements.
  • If your memory is too fragmented, your PC might not have a large enough contiguous block of RAM to store the data.
  • For large structs, storing pointers reduces the amount of contiguous memory needed.

If these 2 criteria don't apply, then there's less benefit in using an array-of-pointers. (Hint: ~500 elements is tiny)

If you want to use an array-of-pointers, do use std::shared_ptr instead of raw pointers so that you don't need to manage the memory explicitly.

If you're willing to use QString in your core logic, your string manipulation code could be simplified greatly.

Example:

Often, the simplest way to solve an overflowing stack due to recursion is to not use recursion.

In this case you can use the following algorithm:

When user clicks an empty block (here, "empty block" means a block with no mine and no adjacent mines):

1. Push the block to an empty stack
2. While the stack is non-empty:
   1. Pop the top item from the stack
   2. If the item is not yet open:
      1. Mark the item as open
      2. Check the item's neighbors - push any empty, non-opened neighbors to the stack and mark any non-mine neighbors that have adjacent mines as open

Here is the central portion of that algorithm: