R – Why can’t compiler derive string length for array of strings

cmemory-managementstackstring

Note: This question was influenced by this answer.

The following is valid C code:

char myString[] = "This is my string";

This will allocate a string of length 18 (including the \0 character) on the stack and assign the specified value to it.

However, the following:

char myStrings[][] = {"My 1st string", "My 2nd string", "My 3rd string"};

is not valid, giving the error "array type has incomplete element type".

So I have to specify the array like this:

char myStrings[][20] = {"My 1st string", "My 2nd string", "My 3rd string"};

Where 20 is a number which is larger than my longest string.

This compiles and works as expected.

If the compiler can dynamically sense the string length when allocating a single string on the stack, why can't it do so for an array of strings?

Edit:

Just to clarify, this is not a real life programming problem I am experiencing – this is just morbid curiosity.

Best Answer

One thing is to "sense" the length of one string. Another thing is to calculate the maximum of lengths of many strings. There's a certain intuitive qualitative difference between the two. So, the language authors probably decided that the former is simple and useful, but the latter is too compilex and less useful.

Implementation in JDK 7

The feature has now been implemented in javac with a "de-sugaring" process; a clean, high-level syntax using String constants in case declarations is expanded at compile-time into more complex code following a pattern. The resulting code uses JVM instructions that have always existed.

A switch with String cases is translated into two switches during compilation. The first maps each string to a unique integer—its position in the original switch. This is done by first switching on the hash code of the label. The corresponding case is an if statement that tests string equality; if there are collisions on the hash, the test is a cascading if-else-if. The second switch mirrors that in the original source code, but substitutes the case labels with their corresponding positions. This two-step process makes it easy to preserve the flow control of the original switch.

Switches in the JVM

For more technical depth on switch, you can refer to the JVM Specification, where the compilation of switch statements is described. In a nutshell, there are two different JVM instructions that can be used for a switch, depending on the sparsity of the constants used by the cases. Both depend on using integer constants for each case to execute efficiently.

If the constants are dense, they are used as an index (after subtracting the lowest value) into a table of instruction pointers—the tableswitch instruction.

If the constants are sparse, a binary search for the correct case is performed—the lookupswitch instruction.

In de-sugaring a switch on String objects, both instructions are likely to be used. The lookupswitch is suitable for the first switch on hash codes to find the original position of the case. The resulting ordinal is a natural fit for a tableswitch.

Both instructions require the integer constants assigned to each case to be sorted at compile time. At runtime, while the O(1) performance of tableswitch generally appears better than the O(log(n)) performance of lookupswitch, it requires some analysis to determine whether the table is dense enough to justify the space–time tradeoff. Bill Venners wrote a great article that covers this in more detail, along with an under-the-hood look at other Java flow control instructions.

Before JDK 7

Prior to JDK 7, enum could approximate a String-based switch. This uses the static valueOf method generated by the compiler on every enum type. For example:

Pill p = Pill.valueOf(str);
switch(p) {
  case RED:  pop();  break;
  case BLUE: push(); break;
}

Python – Why is it string.join(list) instead of list.join(string)

It's because any iterable can be joined (e.g, list, tuple, dict, set), but its contents and the "joiner" must be strings.

For example:

'_'.join(['welcome', 'to', 'stack', 'overflow'])
'_'.join(('welcome', 'to', 'stack', 'overflow'))

'welcome_to_stack_overflow'

Using something other than strings will raise the following error:

TypeError: sequence item 0: expected str instance, int found

Best Answer

Related Solutions

Java – Why can’t I use switch statement on a String

Implementation in JDK 7

Switches in the JVM

Before JDK 7

Python – Why is it string.join(list) instead of list.join(string)

Related Topic