# C Development Under DragonFly BSD Volume 7: Glossary and Tables for all Volumes 


[[!toc  levels=3]]



## Glossary 

### Symbol 




* #define - A keyword that is used to define a macro, variable, etc. for the C preprocessor.
* #include - A keyword that is used to inform the C preprocessor to open another file and process that.
* #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.
* #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.
* #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.
* #endif - A keyword that is used to inform the C preprocessor to end the last #if statement 





### 0 - 9 



### A 



### B 



### C 



#### Comment



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.



### D 



### E 



### F 



### G 



### H 



### I 



#### int 



A C keyword used to express a non-fractional number that is commonly called an integer.



### J 



### K 



#### Keyword 



C keywords are words recognized by the compiler to denote certain operations. A full list of standard keywords includes:



    

    auto        break        case        char        const        continue        default        do

    double      else         enum        extern      float        for             goto           if

    int         long         register    return      short        signed          sizeof         static

    struct      switch       typedef     union       unsigned     void            volatile       while





In addition, GCC allows the use of in-line assembler by using the `asm` keyword.



### L 



### M 



#### Modifier 



Standard C language modifiers include:



    

    auto        extern      register

    static      typedef     volatile





### N 



### O 



#### Operators 



Operators are symbols that when used, perform an operation on one or more operands.  C uses the following operators:



    ,   Used to separate expressions        foo, bar

    =   Assignment                          foo = bar

    ? : Conditional                         foo?bar:baz

    ||  Logical OR                          foo || bar

    &&  Logical AND                         foo && bar
   
    |   Bitwise OR                          foo | bar

    ^   Bitwise Exclusive-OR (XOR)          foo ^ bar

    &   Bitwise AND                         foo & bar

    ==  Equality                            foo == bar

    !=  Inequality                          foo != bar

    <=  Less than or Equals                 foo <= bar

    >=  Greater than or Equals              foo >= bar

    <   Less than                           foo < bar

    >   Greater than                        foo > bar

    <<  Left shift                          foo << bar

    >>  Right shift                         foo >> bar

    +   Addition or no-op                   foo + bar 
                                               or 
                                            +foo

    -   Subtraction or negation             foo - bar 
                                               or 
                                            -foo

    *   Multiplication or de-assignment     foo * bar 
                                               or
                                            *foo

    /   Division                            foo/bar

    %   Modulus                             foo%bar

    ~   Bitwise compliment                  ~foo

    !   Logical compliment                  !foo

    ++  pre- or post- decrement             ++foo or foo++

    --  pre- or post- decrement             --foo or foo--

    ()  Type casting or precedence          (int) foo or (char) foo, etc
                                                      or
                                            (2 + 3) * 8, etc

    ->  Structure de-referencing            foo -> bar

    .   Structure reference                 foo.bar

    []  Array reference                     foo[bar]

    
     
### P 



#### Preprocessor Directive 



### Q 



### R 



### S 



### T 



### U 



### V 



### W 



### X 



### Y 



### Z