All integers that are not perfect squares.
It's a prime number. Therefore the only rectangular array it has is 1*73 (or 73*1)
13...13x1.
A rectangular prism is the only shape that is made up from only rectangular faces. But there are countless shapes which contain rectangular faces along with other shapes.
A rectangular prism or cuboid.
There are many shapes that have one and only one rectangular face, but an example of one would be a rectangular pyramid.
It's a prime number. Therefore the only rectangular array it has is 1*73 (or 73*1)
13...13x1.
No, they are the only numbers that are NOT rectangular in shape. (I think you knew this and screwed up your question.) That is, all non-primes can be arranged into the form of a rectangle - e.g. 21 can be organized as a rectangle with dimensions of 3 x 7. But prime numbers cannot be organized as rectangles.
A rectangular prism, it has 6 rectangular faces.
leakage in arrays occur when you declare an array with big size and using only very few bytes.
There are lots of non-rectangular flags: many of the flags used for maritime signalling are non-rectangular. The only non-rectangular national flag belongs to Nepal.
A rectangular prism is the only shape that is made up from only rectangular faces. But there are countless shapes which contain rectangular faces along with other shapes.
It's actually not true. In order to make a good program which can work with big arrays you have to use dynamic arrays because you can cleam memory used by dymanic arrays any time. For static arrays is not true, memery which was reserved for static arrays will be available for other applications only when you finish working with your application (which is working with static arrays).
A rectangular prism or cuboid.
There are many shapes that have one and only one rectangular face, but an example of one would be a rectangular pyramid.
The foreach construct simply gives an easy way to iterate over arrays. Foreach works only on arrays (and objects).
Exactly as you would any other type of array. An object's size is determined in the same way a structure's size is determined, by the sum total size of its member variables, plus any padding incurred by alignment. However, you cannot create arrays of base classes. Arrays of objects can only be created when the class of object is final; a class that has a private default constructor, otherwise known as a "leaf" class. This is because derived classes can vary in size; array elements must all be the same size. To create an array of base classes you must create an array of pointers to those base classes instead. Pointers are always the same size (4 bytes on a 32-bit system). Static arrays are ideally suited to arrays of leaf objects where the number of objects never changes, or the maximum number of objects is finite and fixed. Although you can use dynamic arrays of leaf objects, you will incur a performance penalty every time the array needs to be resized, because every object's copy constructor must be called during the reallocation. Dynamic arrays are better suited to arrays of pointers to objects -- only the pointers need to be copied during resizing, not the objects they point to.