DragonFly BSD

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

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

Glossary

Symbol

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