View source for C and C++ notes / Types, values, some basic libraries

{{#addbodyclass:tag_tech}}
{{#addbodyclass:tag_prog}}
{{C and Cpp}}


==Literals, initialisation, and such==

<!--
Integers:
* (no modifier) for a not otherwise specified sort of integer. Can lead to ambiguity in some contexts, though the compiler tends to warn about most.
* U for unsigned integer
* L for long integer
* UL for unsigned long integer

* floats:
** F suffix means a float
** no suffix means double (compiler will understand assigning it to a float)
** L suffix means long double.


Strings and characters:
* a single-quoted string is generally used as a byte, e.g. {{inlinecode|<nowiki>char t='0';</nowiki>}}. 
** Note: multi-character single-quoted strings are allowed because you can use them as initializers - e.g. 'ABC' == 0x00414243. Only makes sense when assigning to ints; assigning to bytestrings would truncate it to the ''last'' character.
*** There's also preceding one with L, is that asking for wide-character treatment?{{verify}}

* literal strings mean (a pointer to) what you write ''plus'' a null terminator{{verify}}. As such, you can do:
 char *separator="\r\n\r\n";
 char separator[5]="\r\n\r\n"; // be more careful, though
But not{{verify}}
 char end[3]="\r\n\0"; 

* escapes in strings:
** <tt>\nnn</tt> (octal, 8-bit)
** <tt>\xnn</tt> (hex, 8-bit)
** <tt>\Xnn</tt> (hex, 8-bit)
** <tt>\unnnn</tt> (hex, 16-bit)
** <tt>\Unnnnnnnn</tt> (hex, 32-bit)



* arrays
** you can't initialize an array with an assignment. Don't expect something like <tt>int l[4] = [0, 1, 2, 3];</tt>.
** There are a few compiler-specific ways (but that won't be very portable)
** there is the brace syntax <tt>int l[4] = {0, 1, 2, 3};</tt> 
*** missing elements will be assigned as 0
*** You ''cannot'' use this for runtime assignment
*** on older compilers it seems to be startup-time .data initilisation, and would only work on globals
*** there are some extra notes for multidimensional arrays



Data part of a program can be split into 

* initialized and read-only - considered constants

* initialised and read-write - variables which have initial values copied from the execitable file. Mostly used for globals, as function variables tend to sit in stack frames.

* uninitialised and read-write - {{comment|(also known as Block Started Symbol (BSS), for historical reasons)}}. Almost exactly like the last, but because it's a block of all zeroes at startup time, executable files need only contain the size of this block in the on-disk {{comment|(saving a little disk space)}}, and it's allocated at startup time. {{verify}}

-->

==data/string copying==
<!--
<syntaxhighlight lang="c">
void * memcpy(void *dest, const void *src, size_t n);
void *memmove(void *dest, const void *src, size_t n);

void *memccpy(void *dest, const void *src, int c, size_t n);

char * strcpy(char *dest, const char *src);
char *strncpy(char *dest, const char *src, size_t n);

char * strdup(const char *s);
char *strndup(const char *s, size_t n);

char * strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src, size_t n);
</syntaxhighlight >

memcpy 
* copies ''n'' bytes from ''src'' to ''dest''.
* the two ranges may not overlap

memmove 
* copies ''n'' bytes from ''src'' to ''dest''.
* the two ranges may overlap

memccpy
* copies at most ''n'' bytes from ''src'' to ''dest''; stops at the first value of c
* the two ranges may not overlap

strcpy
* copies null terminated string (including null) from 
* result will be null terminated (assuming the source is, and dest is large enough for it)

strncpy
* copies part of string, stopping at null and after n characters, whichever comes first
* note: no guarantee of null termination

strdup
* much like a malloc+strcpy. Useful to get a copy of something that you shouldn't alter.

strndup
* much like a malloc+strncpy, except that null termination is guaranteed.{{verify}}


Notes:
* C99 also has wide-character versions of strcat, strdup, strcpy, 
* If you malloc the dest for a string copy, it needs to be &ge;strlen(src)+1, for the null terminator (since strlen doesn't count it)

While strcpy necessarily goes on until it sees a null byte (which it copies), strncpy can be told to stop at any point, so it can be effectively equivalent to memcpy, without any null guarantees.
(strncpy is much like memccpy with c='\0').

When copying part of a string, it can make sense to manually set the null after a strncpy.

Note: the strncpy used for the examples sets the region beyond the string to null, but don't count on this. 

As a demonstration: 
<syntaxhighlight lang="c">
void hp(char *buf, int len) {
  for (int i=0;i<len;i++)  printf("%02X ", buf[i]);
  printf("\n");
}

void main(void) {
  //Example of the +1 necessity:
  char buf[16];
  char test[6]="test\r\0"; //in hex: 74 65 73 74 0D 00 
  memset(buf,0x11,16);
  hp(buf,16);

  memset(buf,0x22,16);
  strncpy(buf,test,10);
  hp(buf,16);

  memset(buf,0x33,16);
  strncpy(buf,test,strlen(test)); //that strlen being 4
  hp(buf,16);

  //Example where setting \0 makes sense:
  int pos=strcspn(test,"\r\n\0");
  memset(buf,0x44,16);
  strncpy(buf,test,pos);
  hp(buf,16);
  memset(buf,0x55,16);
  strncpy(buf,test,pos);
  buf[pos]='\0'; //note: you may want to place this under a condition that pos is < the buffer's length
  hp(buf,16);
}
</syntaxhighlight >
Outputs:
 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 
 74 65 73 74 0D 00 00 00 00 00 22 22 22 22 22 22 
 74 65 73 74 0D 33 33 33 33 33 33 33 33 33 33 33 
 74 65 73 74 44 44 44 44 44 44 44 44 44 44 44 44 
 74 65 73 74 00 55 55 55 55 55 55 55 55 55 55 55 
-->

==simple parsing and conversion stuff==
===strings to integers and floats===
<syntaxhighlight lang="c">
int                          atoi(const char *str);
long                         atol(const char *str);
long long                   atoll(const char *str);

long                       strtol(const char *str, char **endptr, int base)
unsigned long int         strtoul(const char *str, char **endptr, int base);
unsigned long long int   strtoull(const char *str, char **endptr, int base);

double                       atof(const char *str);

float                      strtof(const char *str, char **endptr);
double                     strtod(const char *str, char **endptr);
long double               strtold(const char *str, char **endptr);
</syntaxhighlight >
<!--
The integer variants look in <tt>str</tt> for:
* optional string of spaces (using isspace()), to ignore them
* optional sign character (+, -)
* an optional base indicator (0 for octal, X or x for hexadecimal. 0x/0X only if base is 16, only explicitly or also implicitly?{{verify}})
* a string of digits. The first character that does not conform to the base will end the conversion.

<tt>base</tt>, on the functions that mention it:
* 0: assume base 10 unless there is a base indicator in the string
* values in 2..36 to override the base


The floating point variants look for:
* optional leading whitespaces (ignored), using isspace()
* optional sign character (+, -)
* sequence of digits including (optional) decimal point
* optional exponent (e/E, optional sign and a sequence of digits)


<tt>endptr</tt>, on the functions that mention it, and if anything else than NULL, is treated as a char pointer that should be overwritten with a pointer to the character directly beyond the last one the function parsed. This makes it easier to e.g. parse space-separated list of values.



Border/error cases:
* if no sensible characters at start of string, these functions return zero (0, 0.0)
* for integers: if value is outside respective range (e.g. LONG_MIN..LONG_MAX for longs), the closest value (..._MIN or ..._MAX) is returned.  Not all documentation mentions also setting errno is set to ERANGE.{{verify}}
* for floats: if the value would underflow, 0.0 is returned. If the value is outside the representable range, positive/negative HUVE_VAL is returned.
-->

===things to strings===

In C, you usually want one of the '''<tt>printf</tt>''' family -- see [[#printf and variants|the next section]]


In C++, you can choose between <tt>printf</tt> {{comment|(there from <tt>&lt;cstdio&gt;</tt>)}} and '''<tt>cout</tt>''' {{comment|(sometimes less bother than <tt>printf</tt>, sometimes more, though it probably helps your sanity not to mix the two)}}.



Sometimes you'll be given an '''<tt>itoa()</tt>''' and possibly '''<tt>utoa()</tt>''', but this is not part of any C or C++ standard, so not really portable.

For radix 10, 16, or 8, you can use sprintf, respectively (%d or %i or %u), (%x), and (%o).

For other radices you ''could'' copy itoa/utoa's code into your project -- it's only ~15 lines.

For other options, see e.g. [http://stackoverflow.com/questions/228005/alternative-to-itoa-for-converting-integer-to-string-c].

itoa is usually defined as:
<syntaxhighlight lang="c">
char *itoa (int value, char *buffer, int radix);
//and possibly:
char *utoa(unsigned int value, char *buffer, int radix);
</syntaxhighlight >
Notes:
* will write a null-terminated string
* radix should be within 2..36 (uses digits and a-z)
* The default radix is 10 (i.e. decimal)
* on signedness:
** for itoa: If radix!=10, the number is assumed to be unsigned, with 10 it is considered signed.
** '''<tt>utoa</tt>''' (if present) considers everything unsigned
* the buffer should be large enough to hold the result (The worst case length is for binary (radix=2): 17 bytes for a 16-bit int, 33 for a 32-bit int.
* the return value is a copy of *buffer pointer

===printf and variants===
<syntaxhighlight lang="c">
int   printf(const char *format, ...);                          // to stdout
int  fprintf(FILE *stream, const char *format, ...);            // to FILE (file, or stream opened as such)
int  sprintf(char *str, const char *format, ...);               // to target buffer 
int snprintf(char *str, size_t size, const char *format, ...);  // ...same, with call-imposed max chars,
                                                                //          for safety against overflows
</syntaxhighlight >


The same list but with a <tt>v</tt> prepended:
<syntaxhighlight lang="c">
int   vprintf(const char *format, va_list ap);
int  vfprintf(FILE *stream, const char *format, va_list ap);
int  vsprintf(char *str, const char *format, va_list ap);
int vsnprintf(char *str, size_t size, const char *format, va_list ap);
</syntaxhighlight >
Same set, but takes arguments using a <tt>[[va_list]]</tt> instead of a variable number of arguments. 
If you don't know what that means, you probably won't need them.


====format strings====


You know, those things that look like 
 %d
 %-30s
 %.3f
 %-9.3f
 %+-i
 %07d
 %#o

Printf will scan a string for these things, and replace them with value also handed to it, behaving according to the conversion specifier.

They always start with a <tt>%</tt>, end with a conversion specifier, and ''optionally'' any further format details inbetween.


The following focuses on the widely supported stuff, shared by standards or at least most C flavours.

* '''required: {{inlinecode|%}}'''
* optional '''flags''' - mostly for monospaced alignment
** {{inlinecode|+}} : use plus instead of nothing before a positive number {{comment|(like the next, left-aligns better with negative numbers)}}
** {{inlinecode|&nbsp;}} on positive numbers, prepend a single space
** {{inlinecode|-}} : left-justifies numbers instead of the default right justification
** {{inlinecode|0}} pad with zeroes instead of spaces
** {{inlinecode|#}} alternate form:
*** for hex (<tt>x</tt>/<tt>X</tt>) this appends <tt>0x</tt>/<tt>0X</tt> (except to 0)
*** for octal (<tt>o</tt>), this ensures the number starts with a zero
*** <tt>f</tt>/<tt>F</tt>, <tt>e</tt>/<tt>E</tt>, <tt>g</tt>/<tt>G</tt>, a decimal point is always present
*** for g/G, trailing zeroes are not removed as they normally are
** some C-variant-specific flags

* optional: '''minimum field width'''
: Often: a little wider than you expect, to get things to align the same way

* optional: '''precision''', for which the meaning varies a bit:
** integers (d, i, o, u, x, and X): minimum number of digits
** floats   (e, E, f, F, and sometimes a and A): minimum digits after radix character
** floats   (g, G):                 maximum number of significant digits

* optional: '''length modifier''' 

* '''required: conversion specifier'''


----

Where the above says '''conversion specifier''':
* strings and characters:
** <tt>c</tt> - from unsigned char
** <tt>cl</tt> - from wint_t, converted via [https://www.google.com/search?q=wcrtomb wcrtomb]
** <tt>s</tt> - null-terminated string
** <tt>sl</tt> - (wide-)null-terminated string, converted via [https://www.google.com/search?q=wcrtomb wcrtomb]

* signed int:
** <tt>d</tt>, <tt>i</tt> - signed decimal
* unsigned int:
** <tt>u</tt> - unsigned decimal
** <tt>x</tt> - unsigned hex, lowercase abcdef
** <tt>X</tt> - unsigned hex, uppercase ABCDEF
** <tt>o</tt> - unsigned octal
** The # flag prints hex and octal formats in a way that scanf would understand (how standard is this?{{verify}})

* float/double:
** <tt>e</tt>, <tt>E</tt>
*** <tt>[-]d.ddde&#xB1;dd</tt>
*** e/E difference controls whether E in string is lowercase/uppercase
*** exponent ''always'' shown, even if 0 (shown as 00)
*** precision defaults to 6. 
** <tt>f</tt> &nbsp;&nbsp;&nbsp;{{comment|(F exists but is not very standard)}}
*** [-]ddd.ddd
*** precision defaults to 6. 
** <tt>g</tt>, <tt>G</tt>
*** precision defaults to 6. 
*** precision argument specifies significant digits (unlike e, f). &nbsp;&nbsp;Precision of 0 treated as 1.
*** uses <tt>%e</tt> style if <tt>exponent&lt;-4</tt> or if <tt>exponent&gt;precision</tt>, otherwise uses <tt>%f</tt> style {{verify}}
*** (trailing zeroes stripped. If only zeroes after decimal point, decimal point is stripped too)
* also
** <tt>%</tt> - literal %. (so <tt>%%</tt> in format string)
** <tt>p</tt> - pointer as hex, much like %#x or %#lx
<!--** No work done in result string. Instead, the amount of characters written so far is written into the <tt>int *</tt> argument.-->


Examples:
 
     value            %13.4f     %-15.6e           %-+13.6g               % -11.4f              %#13g
       0.3    '       0.3000'  '3.000000e-01   '    '+0.3         '      ' 0.3000    '    '     0.300000'
     0.005    '       0.0050'  '5.000000e-03   '    '+0.005       '      ' 0.0050    '    '   0.00500000'
   -.00007    '      -0.0001'  '-7.000000e-05  '    '-7e-05       '      '-0.0001    '    ' -7.00000e-05'
      5000    '    5000.0000'  '5.000000e+03   '    '+5000        '      ' 5000.0000 '    '      5000.00'

 # more flag stuff
     value                 %x               %#x                 %o                 %#o              %07d
         0                '0'              '0x0'                '0'                '0'          '0000000'
      5000             '1388'           '0x1388'            '11610'           '011610'          '0005000'


 TODO: more examples



Note that localization may create representations that don't necessarily convert back with C's own string-to-text functions, particularly if communicated to another locale. The simplest example is language's preference for a period or comma for its decimal point.

This includes the use of {{inlinecode|'}} to get locale-specific ten-thousand grouping.
To steal an example, <tt>printf("%'.2f", 1234567.89)</tt>
* in POSIX: <tt>1234567.89</tt>
* in nl_NL: <tt>1234567,89</tt>
* in dk_DK: <tt>1.234.567,89</tt>

<!--So when you want portable parsability, -->


See also:
* http://en.wikipedia.org/wiki/Printf_format_string
* http://linux.die.net/man/3/printf

==More complex parsing and conversion==
===strtok(, strtok_r), wcstok===
<syntaxhighlight lang="c">
char *       strtok(   char *str,    const char *delim)
char *     strtok_r(   char *str,    const char *delim,    char **saveptr)
wchar_t *    wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **ptr)
</syntaxhighlight >

{{stub}}

strtok splits a string into a sequence of tokens, which approximately means ''"writes NULL characters onto the next token character and returns the newly terminated token."''
You'll often call it until it returns NULL (which signals that there are no more tokens).

When you want to tokenize a string, you should hand that string into only the ''first'' strtok call. Successive calls should specify NULL for str; specifying a string there signals you want to start over and parse that string instead.

It keeps state between calls. The extra state means that you cannot use strtok() when you're still working on another (e.g. tokenizing a token in a nested for), and that it is not thread-safe.


If, in short, you want to do strtoks that can't affect other strtoks, you'll probably want '''<tt>strtok_r</tt>''' {{comment|(exists on POSIX)}}, a reentrant version that has an extra argument that helps signal which string you want to continue handling.

You can't strtok constant strings, and if you want to keep an unmodified string, you'll probably want to use strdup() (and free() afterwards)


<tt>wcstok()</tt> is the wchar_t version of strtok_r

===strsep===
<!--
char *strsep(char **stringp, const char *delim);

An imitation of strtok that does return empty fields (adjacent delimiters)

-->

==string searching and similar utils==

===searching for characters and substrings===
<syntaxhighlight lang="c">
void *  memchr(const void *str, int c, size_t n)
void * memrchr(const void *str, int c, size_t n)

char *  strchr(const char *str, int c)
char * strrchr(const char *str, int c)
char *   index(const char *str, int c)        // this name apparently deprecated in POSIX
char *  rindex(const char *str, int c)        // this name apparently deprecated in POSIX

char *  strstr(const char *haystack, const char *needle)

char * strpbrk(const char *str, const char *accept)
size_t  strspn(const char *str, const char *accept)
size_t strcspn(const char *str, const char *reject)
</syntaxhighlight >

{{stub}}

Notes:
* <tt>memchr()</tt> returns a pointer to the first occurrence of <tt>c</tt> in memory area specified by <tt>str</tt> (its start) and <tt>n</tt> (its size). memrchr returns the last occurrence.
In both cases, <tt>NULL</tt> is returned if the character is not found.


* <tt>index()</tt> and <tt>strchr()</tt> are similar to memchr, except that they search in a null-terminated string {{comment|(so do null termination checking)}} instead of looking in a memory range.

* <tt>rindex()</tt> and <tt>strrchr()</tt> are much like memrchr ({{comment|though presumably look for the null terminator first and then start searching, while memrchr can look from an immediately calculated address}}{{verify}}).


* <tt>strpbrk()</tt> looks for any one of a number of characters (those in the given null-terminated string), and returns a pointer to the next occurance, or NULL if it is not found.

* <tt>strspn()</tt> returns the ''length'' of the section at the start of the string that consists purely of the given characters (in <tt>accept</tt>).

* <tt>strcspn()</tt> returns the length of the section at the start of the string that does not have any of the given characters (in <tt>reject</tt>).


* <tt>strstr()</tt> looks for the first occurrence of a substring (needle) in a larger string (haystack). If it finds one it returns a pointer within haystack, if not found it returns NULL.




<!--

==Structs and classes==

A class is a type (...definition).

Structs and classes are very similar, with two noticeable differences:
* structs are passed on the stack, objects are on the heap
* struct members are public by default, class members are private by default.


==Object init and destruction==

For all of us for which C++ is too long ago and the ways of other language distract us:

Global
<syntaxhighlight lang="c">
Classname object(arguments);
</syntaxhighlight >

<syntaxhighlight lang="c">
Class foo {
 Classname obj; // actually uses the no-argument constructor
}
</syntaxhighlight >

Classname *obj;
//later...
obj=Classname(arguments)



-->


<!--
==Pass by value/reference/pointer==

==Return by value/pointer==

When you have an easy choice, return by value (primitive/struct) and not by reference, unless you want to take responsibility for (considering) the lifetime of the thing you got a reference to.


Note that whenever you return fixed-size arrays/strings, you could hand in a buffer to write to instead.
Be very sure this will never lead to a buffer overflow, though. 
In more casual, high-level string passing you might as well use safe string objects.



There are also some related bugs, such as returning a local string/array (implicitly by reference). Consider:
 const char* ipv4_to_str(const uint8_t* ipv4_addr) {
   static char buf[16];
   sprintf(buf, "%d.%d.%d.%d", ipv4_addr[0], ipv4_addr[1], ipv4_addr[2], ipv4_addr[3]);
   return buf;
 }

The buffer is large enough, but what happens to it after return, since you're returning a local variable? 

It ''is'' bad code, but sometimes it can accidentally work.

Immediately after returning, the data will still be safely sitting just outside the stack (the stack pointer just got moved to exclude that function's stack frame). 
Your data is in what is considered free stack space, very close to the current stack pointer.

If you use the value immediately and before/without altering the stack, it probably won't be a problem.  But even if it doesn't blow up immediately, it may do so later and unpredictably, or with some later code change.

This because the next function call will write onto what is actually free stack, and given that is is a string, it's relatively likely that you'll call a function to use it.
-->


<!--
==strings, arrays and pointers; pointers and references (objects/classes)==

===arrays and pointers===

Arrays are often thought of as a pointer to the first element. 
That may be how it works under the covers, but that's not how typing works (particularly in C++{{verify}}).


You run into fun when you have '''fixed-size arrays''' 

Consider:
 char ary[4];  //'array of 4 chars'

 char *p1 = ary; // pointer to first item - so much like <tt>&(ary[0])</tt>  
      // Some prefer this, but it may require some trickery to use as an array

 char *p2 = &ary; //invalid: asks for conversion from 
      // pointer to char[12] -> pointer to char

 char (*p3)[4] = &ary; //the right way to do that previous pointer assignment


 char (*p4)[6] = &sz; // invalid: asks for conversion from 
      // pointer to char[4] -> pointer to char[6]

	

Also, the two can mean different things in literal declaration.
 char *p = "hello";  // pointer to string in read-only segment
 char q[] = "hello"; // usual variable, initialized with a string 
   //(and in this case, its length is also determined by the length of the initializer)



See also:
* http://brianbondy.com/blog/id/91/arrays-are-not-the-same-as-pointers
-->


[[Category:Programming]]