docs/developer/C_Development_Under_DragonFly_BSD-Volume_7_Glossary_and_Tables_for_all_Volumes.mdwn

   1 # C Development Under DragonFly BSD Volume 7: Glossary and Tables for all Volumes
   2
   3
   4 [[!toc  levels=3]]
   5
   6
   7
   8 ## Glossary
   9
  10 ### Symbol
  11
  12
  13
  14
  15 * #define - A keyword that is used to define a macro, variable, etc. for the C preprocessor.
  16 * #include - A keyword that is used to inform the C preprocessor to open another file and process that.
  17 * #if - A keyword that is used to inform the C preprocessor to only include the encapsulated code in the program if a given criteria is met.
  18 * #else - A keyword that is used in conjunction with #if that informs the C preprocessor to include the encapsulated code in the program if the criteria is ***not*** matched by the corresponding #if statement.
  19 * #elif - A keyword that is used in conjunction with #if that informs the C preprocessor to include the encapsulated code in the program if the criteria is ***not*** matched by the corresponding #if statement ***and*** it matches the supplied logical statement.
  20 * #endif - A keyword that is used to inform the C preprocessor to end the last #if statement
  21
  22
  23
  24
  25
  26 ### 0 - 9
  27
  28
  29
  30 ### A
  31
  32
  33
  34 ### B
  35
  36
  37
  38 ### C
  39
  40
  41
  42 #### Comment
  43
  44
  45
  46 C comments are statements not interpreted by the compiler and are used by the programmer to leave helpful notes on what is happening in the code.  Comments are contained within the /* and */ symbols.
  47
  48
  49
  50 ### D
  51
  52
  53
  54 ### E
  55
  56
  57
  58 ### F
  59
  60
  61
  62 ### G
  63
  64
  65
  66 ### H
  67
  68
  69
  70 ### I
  71
  72
  73
  74 #### int
  75
  76
  77
  78 A C keyword used to express a non-fractional number that is commonly called an integer.
  79
  80
  81
  82 ### J
  83
  84
  85
  86 ### K
  87
  88
  89
  90 #### Keyword
  91
  92
  93
  94 C keywords are words recognized by the compiler to denote certain operations. A full list of standard keywords includes:
  95
  96
  97
  98
  99
 100     auto        break        case        char        const        continue        default        do
 101
 102     double      else         enum        extern      float        for             goto           if
 103
 104     int         long         register    return      short        signed          sizeof         static
 105
 106     struct      switch       typedef     union       unsigned     void            volatile       while
 107
 108
 109
 110
 111
 112 In addition, GCC allows the use of in-line assembler by using the `asm` keyword.
 113
 114
 115
 116 ### L
 117
 118
 119
 120 ### M
 121
 122
 123
 124 #### Modifier
 125
 126
 127
 128 Standard C language modifiers include:
 129
 130
 131
 132
 133
 134     auto        extern      register
 135
 136     static      typedef     volatile
 137
 138
 139
 140
 141
 142 ### N
 143
 144
 145
 146 ### O
 147
 148
 149
 150 #### Operators
 151
 152
 153
 154 Operators are symbols that when used, perform an operation on one or more operands.  C uses the following operators:
 155
 156
 157
 158     ,   Used to separate expressions        foo, bar
 159
 160     =   Assignment                          foo = bar
 161
 162     ? : Conditional                         foo?bar:baz
 163
 164     ||  Logical OR                          foo || bar
 165
 166     &&  Logical AND                         foo && bar
 167
 168     |   Bitwise OR                          foo | bar
 169
 170     ^   Bitwise Exclusive-OR (XOR)          foo ^ bar
 171
 172     &   Bitwise AND                         foo & bar
 173
 174     ==  Equality                            foo == bar
 175
 176     !=  Inequality                          foo != bar
 177
 178     <=  Less than or Equals                 foo <= bar
 179
 180     >=  Greater than or Equals              foo >= bar
 181
 182     <   Less than                           foo < bar
 183
 184     >   Greater than                        foo > bar
 185
 186     <<  Left shift                          foo << bar
 187
 188     >>  Right shift                         foo >> bar
 189
 190     +   Addition or no-op                   foo + bar
 191                                                or
 192                                             +foo
 193
 194     -   Subtraction or negation             foo - bar
 195                                                or
 196                                             -foo
 197
 198     *   Multiplication or de-assignment     foo * bar
 199                                                or
 200                                             *foo
 201
 202     /   Division                            foo/bar
 203
 204     %   Modulus                             foo%bar
 205
 206     ~   Bitwise compliment                  ~foo
 207
 208     !   Logical compliment                  !foo
 209
 210     ++  pre- or post- decrement             ++foo or foo++
 211
 212     --  pre- or post- decrement             --foo or foo--
 213
 214     ()  Type casting or precedence          (int) foo or (char) foo, etc
 215                                                       or
 216                                             (2 + 3) * 8, etc
 217
 218     ->  Structure de-referencing            foo -> bar
 219
 220     .   Structure reference                 foo.bar
 221
 222     []  Array reference                     foo[bar]
 223
 224
 225
 226 ### P
 227
 228
 229
 230 #### Preprocessor Directive
 231
 232
 233
 234 ### Q
 235
 236
 237
 238 ### R
 239
 240
 241
 242 ### S
 243
 244
 245
 246 ### T
 247
 248
 249
 250 ### U
 251
 252
 253
 254 ### V
 255
 256
 257
 258 ### W
 259
 260
 261
 262 ### X
 263
 264
 265
 266 ### Y
 267
 268
 269
 270 ### Z
 271