user3559: I'd like to make three arrays of the same length. According to the documentation, Arrays must be defined as int myArray[10]; where 10 can be substituted for a known length (another integer), or filled with an array {2, 3, 5, 6, 7}.
However, when I attempted to declare a value int arrSize = 10; and then an array based on that size int myArray[arrSize];, I get the following: error: array bound is not an integer constant. 
Is there a way to variably determine array sizes, or do I just need to hardcode them? (I was taught hardcoding is bad and something to avoid at all costs.)

user43025: If you know the maximum length of array, just initialize the array to that length and use an integer to tell the program how much of that array to use.  If it's the difference between 7,10 bytes then you are not wasting that much memory allocation.  

user53044: I know I'm a little late here, but in theory regular arrays can't be created using a variable to define the amount of elements the array is going to have as in: 
int arrSize;
int myArray[arrSize];

This will display an error since when declaring the array, the program expects for the value between the brackets to be a constant. Yet, there is a way in which you could create an array with a variable defining the amount of values this arrays is going to have through dynamic memory allocation for value sets (this method has been tested with monodimensional arrays only, haven't tried for multidimensional yet), and it goes something like this: 
//First you create a pointer for the memory space to be separated for the set you're creating
int* myArray;
int arrSize; //Then you define the variable that will determine the amount of elements the array is going to have, you can give it a value whenever you want as long as this int is defined before the values in myArray are set 
myArray=(int*)calloc(arrSize,sizeof(int)) //Here, you establish that the instance myArray (whose memory space has already been separated through the creation of the pointer) will be separated into arrSize amount of elements of type int with a maximum memory value (in bytes) equal to the maximum available for the int type variables

After this, all that's left to do is assign a value for every element created in the instance myArray (which is already an Array by now) as you would for a normal array created as myArray[arrSize].

user84: Your question has 2 parts actually.
1/ How can I declare the constant size of an array outside the array?
You can either use a macro
#define ARRAY_SIZE 10
...
int myArray[ARRAY_SIZE];

or use a constant
const int ARRAY_SIZE = 10;
...
int myArray[ARRAY_SIZE];

if you initialized the array and you need to know its size then you can do:
int myArray[] = {1, 2, 3, 4, 5};
const int ARRAY_SIZE = sizeof(myArray) / sizeof(int);

the second sizeof is on the type of each element of your array, here int.
2/ How can I have an array which size is dynamic (i.e. not known until runtime)?
For that you will need dynamic allocation, which works on Arduino, but is generally not advised as this can cause the "heap" to become fragmented.
You can do (C way):
// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source)
if (myArray != 0) {
    myArray = (int*) realloc(myArray, size * sizeof(int));
} else {
    myArray = (int*) malloc(size * sizeof(int));
}

Or (C++ way):
// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source or through other program logic)
if (myArray != 0) {
    delete [] myArray;
}
myArray = new int [size];

For more about problems with heap fragmentation, you can refer to this question.

3559: <p>I'd like to make three arrays of the same length. According to the <a href="http://arduino.cc/en/Reference/array">documentation</a>, Arrays must be defined as <code>int myArray[10];</code> where 10 can be substituted for a known length (another integer), or filled with an array <code>{2, 3, 5, 6, 7}</code>.</p>

<p>However, when I attempted to declare a value <code>int arrSize = 10;</code> and then an array based on that size <code>int myArray[arrSize];</code>, I get the following: <code>error: array bound is not an integer constant</code>. </p>

<p>Is there a way to variably determine array sizes, or do I just need to hardcode them? (I was taught hardcoding is bad and something to avoid at all costs.)</p>
 43025: <p>If you know the maximum length of array, just initialize the array to that length and use an integer to tell the program how much of that array to use.  If it's the difference between 7,10 bytes then you are not wasting that much memory allocation.  </p>
 53044: <p>I know I'm a little late here, but in theory regular arrays can't be created using a variable to define the amount of elements the array is going to have as in: </p>

<pre><code>int arrSize;
int myArray[arrSize];
</code></pre>

<p>This will display an error since when declaring the array, the program expects for the value between the brackets to be a constant. Yet, there is a way in which you could create an array with a variable defining the amount of values this arrays is going to have through dynamic memory allocation for value sets (this method has been tested with monodimensional arrays only, haven't tried for multidimensional yet), and it goes something like this: </p>

<pre><code>//First you create a pointer for the memory space to be separated for the set you're creating
int* myArray;
int arrSize; //Then you define the variable that will determine the amount of elements the array is going to have, you can give it a value whenever you want as long as this int is defined before the values in myArray are set 
myArray=(int*)calloc(arrSize,sizeof(int)) //Here, you establish that the instance myArray (whose memory space has already been separated through the creation of the pointer) will be separated into arrSize amount of elements of type int with a maximum memory value (in bytes) equal to the maximum available for the int type variables
</code></pre>

<p>After this, all that's left to do is assign a value for every element created in the instance myArray (which is already an Array by now) as you would for a normal array created as myArray[arrSize].</p>
 84: <p>Your question has 2 parts actually.</p>

<p><strong>1/ How can I declare the constant size of an array outside the array?</strong></p>

<p>You can either use a macro</p>

<pre><code>#define ARRAY_SIZE 10
...
int myArray[ARRAY_SIZE];
</code></pre>

<p>or use a constant</p>

<pre><code>const int ARRAY_SIZE = 10;
...
int myArray[ARRAY_SIZE];
</code></pre>

<p>if you initialized the array and you need to know its size then you can do:</p>

<pre><code>int myArray[] = {1, 2, 3, 4, 5};
const int ARRAY_SIZE = sizeof(myArray) / sizeof(int);
</code></pre>

<p>the second <code>sizeof</code> is on the type of each element of your array, here <code>int</code>.</p>

<p><strong>2/ How can I have an array which size is dynamic (i.e. not known until runtime)?</strong></p>

<p>For that you will need dynamic allocation, which works on Arduino, but is generally not advised as this can cause the "heap" to become fragmented.</p>

<p>You can do (C way):</p>

<pre><code>// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source)
if (myArray != 0) {
    myArray = (int*) realloc(myArray, size * sizeof(int));
} else {
    myArray = (int*) malloc(size * sizeof(int));
}
</code></pre>

<p>Or (C++ way):</p>

<pre><code>// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source or through other program logic)
if (myArray != 0) {
    delete [] myArray;
}
myArray = new int [size];
</code></pre>

<p>For more about problems with heap fragmentation, you can refer to <a href="https://arduino.stackexchange.com/questions/682/is-using-malloc-and-free-a-really-bad-idea-on-arduino">this question</a>.</p>
