I&#39;m experimenting to learn flex and would like to match string literals. My code currently looks like:

    &quot;\&quot;&quot;([^\n\&quot;\\]*(\\[.\n])*)*&quot;\&quot;&quot;        {/*matches string-literal*/;}

I&#39;ve been struggling with variations for an hour or so and can&#39;t get it working the way it should. I&#39;m essentially hoping to match a string literal that can&#39;t contain a new-line (unless it&#39;s escaped) and supports escaped characters.

I am probably just writing a poor regular expression or one incompatible with flex. Please advise!

Regular expression for a string literal in flex/lex

In [C#][1], [Ruby][2], and many other languages you can denote a string as to not need escaping.
In C# it’s like this

&lt;!-- language: lang-csharp --&gt;

    string s = @&quot;\whatever\this\is&quot;;

The results are when printed:

    \whatever\this\is

Is this supported in any form in JavaScript?

  [1]: https://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29
  [2]: https://en.wikipedia.org/wiki/Ruby_%28programming_language%29


Does JavaScript have literal strings?

```c
#include &lt;stdio.h&gt;

int main() {
    char a = 5;
    char b[2] = &quot;hi&quot;; // No explicit room for `\0`.
    char c = 6;

    return 0;
}
```
&gt; Whenever we write a string, enclosed in double quotes, C automatically creates an array of characters for us, containing that string, terminated by the \0 character
http://www.eskimo.com/~scs/cclass/notes/sx8.html

In the above example `b` only has room for 2 characters so the null terminating char doesn&#39;t have a spot to be placed at and yet the compiler is reorganizing the memory store instructions so that `a` and `c` are stored before `b` in memory to make room for a `\0` at the end of the array.

Is this expected or am I hitting undefined behavior?  

Are char arrays guaranteed to be null terminated?

I&#39;m compiling the following program using Microsoft Visual C++, as a C++20 program:

    #include &lt;iostream&gt;
    #include &lt;tuple&gt;
    
    int main()
    {
    	auto t1 = std::make_tuple(&quot;one&quot;, &quot;two&quot;, &quot;three&quot;);
    	auto t2 = std::make_tuple(&quot;one&quot;, &quot;two&quot;, &quot;three&quot;);
    	
    	std::cout &lt;&lt; &quot;(t1 == t2) is &quot; &lt;&lt; std::boolalpha &lt;&lt; (t1 == t2) &lt;&lt; &quot;\n&quot;;
    	std::cout &lt;&lt; &quot;(t1 != t2) is &quot; &lt;&lt; std::boolalpha &lt;&lt; (t1 != t2) &lt;&lt; &quot;\n&quot;;
    
    	return 0;
    }

When I run it, I see the following output:

    (t1 == t2) is false
    (t1 != t2) is true

The tuples are identical, so why does it have wrong comparison results? How do I fix this?

Why are my two tuples containing strings, created the same way, not equal?

In JavaScript, I can declare a string in the following ways;

    var a = &quot;Hello World&quot;;
    var b = new String(&quot;Hello World&quot;);

but a is not an instance of String...

    console.log(a instanceof String); //false;
    console.log(b instanceof String); //true;

So how do you find the type or &quot;`instanceof`&quot; a string literal?

Can JavaScript be forced to create a `new String()` for every string literal?

How to &quot;instanceof&quot; a primitive string (string literal) in JavaScript

I have a C++ source file and a Python source file. I&#39;d like the C++ source file to be able to use the contents of the Python source file as a big string literal. I could do something like this:

    char* python_code = &quot;
    #include &quot;script.py&quot;
    &quot;

But that won&#39;t work because there need to be \&#39;s at the end of each line. I could manually copy and paste in the contents of the Python code and surround each line with quotes and a terminating \n, but that&#39;s ugly. Even though the python source is going to effectively be compiled into my C++ app, I&#39;d like to keep it in a separate file because it&#39;s more organized and works better with editors (emacs isn&#39;t smart enough to recognize that a **C** string literal is python code and switch to python mode while you&#39;re inside it).

Please don&#39;t suggest I use PyRun_File, that&#39;s what I&#39;m trying to avoid in the first place ;)

C/C++, can you #include a file into a string literal?

The two characters `)&quot;` terminate the raw string literal in the example below. &lt;br&gt;
The sequence `)&quot;` could appear in my text at some point, and I want the string to continue even if this sequence is found within it.

    R&quot;(  
        Some Text)&quot;  
    )&quot;;       // ^^
   

How can I include the sequence `)&quot;` within the string literal without terminating it?

Include )&quot; in raw string literal without terminating said literal

What is the difference between 

    String str = new String(&quot;abc&quot;);

and 

    String str = &quot;abc&quot;;

Difference between string object and string literal

When should I use single quotes and double quotes in C or C++ programming?


Single quotes vs. double quotes in C or C++

What is the best way to represent a Windows directory, for example `&quot;C:\meshes\as&quot;`? I have been trying to modify a script but it never works because I can&#39;t seem to get the directory right, I assume because of the `&#39;\&#39;` acting as escape character?

Windows path in Python

I have the above-mentioned error in `s1=&quot;some very long string............&quot;` 

Does anyone know what I am doing wrong?


python: SyntaxError: EOL while scanning string literal

I am interested in where string literals get allocated/stored.

I did find one intriguing answer [here][1], saying:

&gt; Defining a string inline actually embeds the data in the program itself and cannot be changed (some compilers allow this by a smart trick, don&#39;t bother).

But, it had to do with C++, not to mention that it says not to bother.

I am bothering. =D

So my question is where and how is my string literal kept? Why should I not try to alter it? Does the implementation vary by platform? Does anyone care to elaborate on the &quot;smart trick?&quot;

  [1]: https://stackoverflow.com/questions/51592/is-there-a-need-to-destroy-char-string-or-char-new-char6/51607#51607

String literals: Where do they go?

I have a table `test(id,name)`.

I need to insert values like:  `user&#39;s log`, `&#39;my user&#39;`, `customer&#39;s`.

     insert into test values (1,&#39;user&#39;s log&#39;);
     insert into test values (2,&#39;&#39;my users&#39;&#39;);
     insert into test values (3,&#39;customer&#39;s&#39;);

I am getting an error if I run any of the above statements.

If there is any method to do this correctly please share. I don&#39;t want any prepared statements.

Is it possible using sql escaping mechanism?



Insert text with single quotes in PostgreSQL

Is there any way to have multi-line plain-text, constant literals in C++, &#224; la Perl? Maybe some parsing trick with `#include`ing a file? I can&#39;t think of one, but boy, that would be nice. I know it&#39;ll be in C++0x.

C++ multiline string literal

I am trying to figure out how to write a macro that will pass both a string literal representation of a variable name along with the variable itself into a function.

For example given the following function.

    void do_something(string name, int val)
    {
       cout &lt;&lt; name &lt;&lt; &quot;: &quot; &lt;&lt; val &lt;&lt; endl;
    }

I would want to write a macro so I can do this:

    int my_val = 5;
    CALL_DO_SOMETHING(my_val);

Which would print out: `my_val: 5`

I tried doing the following:

    #define CALL_DO_SOMETHING(VAR) do_something(&quot;VAR&quot;, VAR);

However, as you might guess, the VAR inside the quotes doesn&#39;t get replaced, but is just passed as the string literal &quot;VAR&quot;. So I would like to know if there is a way to have the macro argument get turned into a string literal itself.


How to use Macro argument as string literal?

I&#39;m trying to compute the length of a string literal at compile time. To do so I&#39;m using following code:

    #include &lt;cstdio&gt;
    
    int constexpr length(const char* str)
    {
        return *str ? 1 + length(str + 1) : 0;
    }
    
    int main()
    {
        printf(&quot;%d %d&quot;, length(&quot;abcd&quot;), length(&quot;abcdefgh&quot;));
    }

Everything works as expected, the program prints 4 and 8. The assembly code generated by clang shows that the results are computed at compile time:

    0x100000f5e:  leaq   0x35(%rip), %rdi          ; &quot;%d %d&quot;
    0x100000f65:  movl   $0x4, %esi
    0x100000f6a:  movl   $0x8, %edx
    0x100000f6f:  xorl   %eax, %eax
    0x100000f71:  callq  0x100000f7a               ; symbol stub for: printf

**My question: is it guaranteed by the standard that `length` function will be evaluated compile time?** 

If this is true the door for compile time string literals computations just opened for me... for example I can compute hashes at compile time and many more... 

Computing length of a C string at compile time. Is this really a constexpr?

I want to have a percentage sign in my string after a digit. Something like this: 75%.

How can I have this done? I tried:

    [NSString stringWithFormat:@&quot;%d\%&quot;, someDigit];
But it didn&#39;t work for me.

How to add percent sign to NSString

https://godbolt.org/z/cyBiWY

I can see two `&#39;some&#39;` literals in assembler code generated by MSVC, but only one with clang and gcc. This leads to totally different results of code execution.

    static const char *A = &quot;some&quot;;
    static const char *B = &quot;some&quot;;
    
    void f() {
        if (A == B) {
            throw &quot;Hello, string merging!&quot;;
        }
    }

Can anyone explain the difference and similarities between those compilation outputs? Why does clang/gcc optimize something even when no optimizations are requested? Is this some kind of undefined behaviour?

I also notice that if I change the declarations to those shown below, clang/gcc/msvc do not leave any `&quot;some&quot;` in the assembler code at all. Why is the behaviour different?

    static const char A[] = &quot;some&quot;;
    static const char B[] = &quot;some&quot;;

Why do (only) some compilers use the same address for identical string literals?

Wouldn&#39;t the pointer returned by the following function be inaccessible?

    char *foo(int rc)
    {
        switch (rc)
        {
            case 1:

                return(&quot;one&quot;);

            case 2:

                return(&quot;two&quot;);

            default:

                return(&quot;whatever&quot;);
        }
    }

So the lifetime of a local variable in C/C++ is practically only within the function, right? Which means, after `char* foo(int)` terminates, the pointer it returns no longer means anything, right?

I&#39;m a bit confused about the lifetime of a local variable. What is a good clarification?


&quot;Life-time&quot; of a string literal in C

I saw the operator `r#&quot;&quot;` in Rust but I can&#39;t find what it does. It came in handy for creating JSON:

    let var1 = &quot;test1&quot;;
    let json = r#&quot;{&quot;type&quot;: &quot;type1&quot;, &quot;type2&quot;: var1}&quot;#;
    println!(&quot;{}&quot;, json) // =&gt; {&quot;type2&quot;: &quot;type1&quot;, &quot;type2&quot;: var1}

What&#39;s the name of the operator `r#&quot;&quot;`? How do I make `var1` evaluate?

What is the r#&quot;&quot;# operator in Rust?

Following a [related question](https://stackoverflow.com/questions/6794590/how-does-file-encoding-affect-c11-string-literals), I&#39;d like to ask about the new character and string literal types in C++11. It seems that we now have four sorts of characters and five sorts of string literals. The character types:

    char     a =  &#39;\x30&#39;;         // character, no semantics
    wchar_t  b = L&#39;\xFFEF&#39;;       // wide character, no semantics
    char16_t c = u&#39;\u00F6&#39;;       // 16-bit, assumed UTF16?
    char32_t d = U&#39;\U0010FFFF&#39;;   // 32-bit, assumed UCS-4

And the string literals:

    char     A[] =  &quot;Hello\x0A&quot;;         // byte string, &quot;narrow encoding&quot;
    wchar_t  B[] = L&quot;Hell\xF6\x0A&quot;;      // wide string, impl-def&#39;d encoding
    char16_t C[] = u&quot;Hell\u00F6&quot;;        // (1)
    char32_t D[] = U&quot;Hell\U000000F6\U0010FFFF&quot;; // (2)
    auto     E[] = u8&quot;\u00F6\U0010FFFF&quot;; // (3)

The question is this: Are the `\x`/`\u`/`\U` character references freely combinable with all string types? Are all the string types fixed-width, i.e. the arrays contain precisely as many elements as appear in the literal, or to `\x`/`\u`/`\U` references get expanded into a variable number of bytes? Do `u&quot;&quot;` and `u8&quot;&quot;` strings have encoding semantics, e.g. can I say `char16_t x[] = u&quot;\U0010FFFF&quot;`, and the non-BMP codepoint gets encoded into a two-unit UTF16 sequence? And similarly for `u8`? In (1), can I write lone surrogates with `\u`? Finally, are any of the string functions encoding aware (i.e. they are character-aware and can detect invalid byte sequences)?

This is a bit of an open-ended question, but I&#39;d like to get as complete a picture as possible of the new UTF-encoding and type facilities of the new C++11.

Unicode encoding for string literals in C++11

There is a very convenient feature introduced in C++11 called raw string literals, which are strings with no escape characters. And instead of writing this:

      regex mask(&quot;\\t[0-9]+\\.[0-9]+\\t\\\\SUB&quot;);

You can simply write this:

      regex mask(R&quot;(\t[0-9]+\.[0-9]+\t\\SUB)&quot;);

Quite more readable. However, note extra parenthesis around the string one have to place to define a raw string literal. 

My question is, why do we even need these? For me it looks quite ugly and illogical. Here are the cons what I see:

 - Extra verbosity, while the whole feature is used to make literals more compact
 - Hard to distinguish between the body of the literal and the defining symbols

That&#39;s what I mean by the hard distinguishing:

    &quot;good old usual string literal&quot;
     ^-    body inside quotes   -^

    R&quot;(new strange raw string literal)&quot;
       ^- body inside parenthesis  -^

And here is the pro:

 - More flexibility, more characters available in raw strings, especially when used with the delimiter: `&quot;delim( can use &quot;()&quot; here )delim&quot;`

But hey, if you need more flexibility, you have old good escapeable string literals. Why the standard committee decided to pollute the content of every raw string literal with these absolutely unnecessary parenthesis? What was the rationale behind that? What are the pros I didn&#39;t mention?

**UPD** The answer by Kerrek is great, but it is not an answer, unfortunately. Since I already described that I understand how it works and what benefits does it give. Five years passed since I&#39;ve asked this question, and still there is no answer. And I am still frustrated by this decision. One could say that this is a matter of taste, but I would disagree. How many spaces do you use, how do you name your variables, is this `SomeFunction()` or `some_function()` - this is the matter of taste. And I can really easily switch from one style to another.

But this?.. Still feels awkward and clumsy after so many years. No, this is not about the taste. This is about how we want to cover all possible cases no matter what. We doomed to write these ugly parens every time we need to write a Windows-specific path, or a regular expression, or a multi-line string literal. And for what?.. For those rare cases when we actually need to put `&quot;` in a string? I wish I was on that committee meeting where they decided to do it this way. And I would be strongly against this really bad decision. I wish. Now we are doomed.

Thank you for reading this far. Now I feel a little better.

**UPD2** Here are my alternative proposals, which I think both would be MUCH better than existing.

Proposal 1. Inspired by python. Cannot support string literals with triple quotes: `R&quot;&quot;&quot;Here is a string literal with any content, except for triple quotes, which you don&#39;t actually use that often.&quot;&quot;&quot;`

Proposal 2. Inspired by common sense. Supports all possible string literals, just like the current one: `R&quot;delim&quot;content of string&quot;delim&quot;`. With empty delimiter: `R&quot;&quot;Looks better, doesn&#39;t it?&quot;&quot;`. Empty raw string: `R&quot;&quot;&quot;&quot;`. Raw string with double quotes: `R&quot;#&quot;Here are double quotes: &quot;&quot;, thanks&quot;#&quot;`.

Any problems with these proposals?

What is the rationale for parenthesis in C++11&#39;s raw string literals R&quot;(...)&quot;?

**C++03 5.1 Primary expressions &#167;2** says:

&gt; A literal is a primary expression. Its type depends on its form (2.13). A string literal is an lvalue; all other literals are rvalues.

Similarly, **C99 6.5.1 &#167;4** says:

&gt; A string literal is a primary expression. It is an lvalue with type as detailed in 6.4.5.

What is the rationale behind this?

As I understand, string literals are objects, while all other literals are not. And an l-value always refers to an object.

But the question then is why are string literals objects while all other literals are not? This rationale seems to me more like an egg or chicken problem.

I understand the answer to this may be related to hardware architecture rather than C/C++ as programming languages, nevertheless I would like to hear the same.

Why are string literals l-value while all other literals are r-value?

I know I can define string union types to restrict variables to one of the possible string values:

    type MyType = &#39;first&#39; | &#39;second&#39;
    let myVar:MyType = &#39;first&#39;

I need to construct a type like that from constant strings, e.g:

    const MY_CONSTANT = &#39;MY_CONSTANT&#39;
    const SOMETHING_ELSE = &#39;SOMETHING_ELSE&#39;
    type MyType = MY_CONSTANT | SOMETHING_ELSE

But for some reason it doesn&#39;t work; it says `MY_CONSTANT refers to a value, but it being used as a type here`.

Why does Typescript allow the first example, but doesn&#39;t allow the second case? I&#39;m on Typescript 3.4.5

How to define string literal union type from constants in Typescript

I have a pretty long sqlite query:

    const char *sql_query = &quot;SELECT statuses.word_id FROM lang1_words, statuses WHERE statuses.word_id = lang1_words.word_id ORDER BY lang1_words.word ASC&quot;;

How can I break it in a number of lines to make it easier to read?
If I do the following:

    const char *sql_query = &quot;SELECT word_id
                            FROM table1, table2
                            WHERE table2.word_id = table1.word_id
                            ORDER BY table1.word ASC&quot;;

I am getting an error.

Is there a way to write queries in multiple lines?

How to split a string literal across multiple lines in C / Objective-C?

I&#39;m a c++ newbie (just oldschool c).   My son asked for help with this and I&#39;m unable to explain it.   If he had asked me &quot;how do I compare strings&quot; I would have told him to use strcmp(), but that isn&#39;t what is confusing me.   Here is what he asked:

    int main() 
    { 
      cout &lt;&lt; (&quot;A&quot;&lt; &quot;Z&quot;);
    }

will print 1

    int main() 
    { 
      cout &lt;&lt; (&quot;Z&quot;&lt; &quot;A&quot;);
    }
will also print 1, but

    int main() 
    { 
      cout &lt;&lt; (&quot;Z&quot;&lt; &quot;A&quot;);
      cout &lt;&lt; (&quot;A&quot;&lt; &quot;Z&quot;);
    }

will then print 10.   Individually both cout statements print 1, but executed in a row I get a different answer?  

C++ Comparison of String Literals

In the following example:

    cout&lt;&lt;&quot;\n&quot;[a==N];

I have no clue about what the `[]` option does in `cout`, but it does not print a newline when the value of `a` is equal to `N`.

what does cout &lt;&lt; &quot;\n&quot;[a==N]; do?

I noticed that string literals have very different addresses in memory than other constants and variables (Linux OS): they have many leading zeroes (not printed).

Example:
   
    const char *h = &quot;Hi&quot;;
    int i = 1;
    printf (&quot;%p\n&quot;, (void *) h);
    printf (&quot;%p\n&quot;, (void *) &amp;i);
    
Output:

    0x400634
    0x7fffc1ef1a4c

I know they are stored in the `.rodata` part of the executable. Is there a special way the OS handles it afterwards, so the literals end up in a special area of memory (with leading zeroes)? Are there any advantages of that memory location or is there something special about it?

Why are the memory addresses of string literals so different from others&#39;, on Linux?

How can I encode the Unicode character U+0048 (H), say, in a PowerShell string?

In C# I would just do this: `&quot;\u0048&quot;`, but that doesn&#39;t appear to work in PowerShell.


How do I encode Unicode character codes in a PowerShell string literal?

Consider following code:

    char str[] = &quot;Hello\0&quot;;

What is the length of str array, and with how much 0s it is ending?

All String Literals Solutions on Gang of Coders

Total of 30 String Literals Solutions