Why were single quotes ('…') chosen for characters, and double quotes ("…") for strings?

Question

In C, '' is used to denote a character, while "" is used to denote a string. Why was this syntax chosen?

I tried to research this using Wikipedia’s Timeline of Programming Languages along with Rosetta Code’s reference page for strings. It seems that C was the first widespread programming language which implemented this, since in popular languages before it like Pascal, ALGOL, COBOL and FORTRAN, '' and "" were interchangeable, or only one of them was used.

I know that it might seem like an obvious choice to use '' for characters and "" for strings, but it actually isn’t. Before programming, these symbols were only used in punctuation, and there is no such rule or convention that '' should be used when quoting smaller things.

Since I found Why was `!` chosen for negation? and Why was "C:" chosen for the first hard drive partition? on this SE site, I figured that this is the right place to ask this.

Answer 1

For type system reasons, and for compatibility with B.

B is a programming language that served as the immediate ancestor of C. The salient thing about B is that it had no type system: all values in B are machine words (corresponding to the C type int). In B, there were two ways to represent strings in source code: string literals⁰, which evaluated to a pointer to a block of memory holding the string, and multi-character literals, which packed multiple character codes directly into a single machine word. The latter were famously used in Kernighan’s original ‘Hello, world’ program:

main( ) {
 extrn a, b, c;
 putchar(a); putchar(b); putchar(c); putchar('!*n');
}
a 'hell';
b 'o, w';
c 'orld';

Since the two kinds of values behaved so differently, yet could not be distinguished at the type system level (because there was none), they had to use different syntaxes.

As C is an evolution of B, it simply inherited all this baggage and could not change it without breaking compatibility. Although some breaking changes to the syntax were made in C after all, there apparently wasn’t a compelling enough reason to make one here. The weak typing of C does maintain a certain kind of continuity with B after all.

The above, though, raises the question of why such distinction was made in B. Since B was conceived as a simplified version of BCPL, one may think there might be some answers in materials about that language. But according to the manual, in BCPL character literals and string literals were not differentiated by delimiters, but by their length:

A string constant of length one has an Rvalue which is the bit pattern representation of the character; this is right justified and filled with zeros.

A string constant with length other than one is represented as a BCPL vector [i.e. array]; the length and the string characters are packed in successive words of the vector.

So the delimiter distinction between character literals and string literals was first made in B. As to why, and why the syntax was chosen the way it was, we are probably resigned to rely on speculation, as neither Users' Reference to B nor A Tutorial Introduction to the Language B nor The Development of the C Language elaborate on that particular topic. My hypothesis would be:

• Because B allowed multiple characters in its character literals, it could no longer rely on differentiating characters from strings by the length of the literal (and because again, B had no type system to transparently inter-convert between them), and thus a syntactic distinction was necessary.
• Character literals, as conceptually more lightweight (not requiring additional storage), were assigned the glyph that was (visually) simpler and took fewer keystrokes to type. (I shamelessly stole this one from @Toby Speight.)

This explanation is mostly conjecture, but it seems we may have a hard time finding a better one.

---

⁰ Contemporaneous documentation used the term ‘constant’ instead of ‘literal’, since it was the only kind available back then anyway.

Answer 2

Not quite the same thing, but PDP-11 assemblers used 'X as a single character value (i.e., a byte), and "XY as a two-character value, (i.e., a word).

MOV  #"EH, BUFF
MOVB #'?, BUFF+2

The single/double quote corresponds nicely to the number of characters involved.

Ritchie et. al. would surely have been aware of this DEC convention. In fact, the same convention was carried over into the Unix assembler 'as' - which according to its man page was derived from the DEC assembler PAL-11R.

References: (both from 1971)

DEC usage: section 4.3 in this PAL-11R programmer's manual

Unix usage: section as(I) in the UNIX programmer's manual

FWIW, in DEC syntax, strings were rather different: a specific pseudo-op was used to declare strings, with arbitrary delimiter pairs, though slashes were conventional:

.ASCII /EH?/
.ASCII ZEH?Z

Answer 3

Consider how other languages handled characters. Many languages represented characters as strings of length 1, rather than their own type. These were inefficient in several ways:

• The source code was more verbose. Compare

  IF MID$(Q$,1,1) = "A" THEN
  

  to

  if (q[0] == 'A')
  

• Operations such as extracting one character or performing a comparison are more efficient with character types than with strings. The MID$ operation above allocates and copies yet another string. The = operation requires scanning through the two strings involved.

• For compiled languages, character literals take up less space than string literals, both on disk and as a loaded program. String literals need to allocate space for the characters, the length or terminating character, and the address which references the string. Character literals can simply be an immediate operand of the instruction you were going to compile anyway.

• There were also constructs like CHR$(65), whereas 'A' is both more efficient and easier to understand.

As the intent of C is to create highly-efficient programs, it was necessary to have a character type separate from string types. In turn, this meant having a way to represent character literals separately from string literals.

Modern compilers probably could determine the data type from the surrounding context, but early compilers simply weren't that sophisticated.

Answer 4

In C, '' is used to denote a character, while "" is used to denote a string. Why was this syntax chosen?

The syntax difference is to describe two different constructs:

• A character is a single value, used with its value, while
• A string is an array of values, usually being pointed to.

Most important, without making that distinction, it would be impossible for a compiler to decide if "A" would refer to a character (value) of A, or define a string containing a single character A (with delimiting length or terminator)

Important for compiler construction: Having that distinction made upfront, with the first symbol of that token, simplifies the parser. Much like writing 0x in front of a hex number saves effort in seeing if it's a number or something else. The parser dos not have to read the whole token to see what it is about, but can go ahead according to that the leading symbol says.

Due to this necessity, two different quotes are needed.

Now why exactly these two were selected is hard to say, but it would seem intuitive that the single is for some short quote, while the double cover some longer item. This is as well kind of consistent with usage in English language writing, where speech and other quotation is primary between double marks. Which makes a lot of sense as regular English writing contains lots of single marks for concatenations and abbreviation.

It seems that C was the first widespread programming language which implemented this

C inherited it from B, which introduced this differentiation as part of its simplification from BCPL. B was written by Ken Thompson and Dennis Ritchie, who later went on to create C.