$ gcc hello.c
$ ./a.out

The default, if no C language dialect options are given, is -std=gnu17.

Published in June 2018, C17 is the current standard for the C programming language.

gcc -save-temps hello.c -o hello

• -save-temps flag is used to save all the intermediate files during compilation.

files

• hello.i (Generated by Pre-processr) - Lines starting with a # are interpreted by the preprocessor
• hello.s (Generated by Compiler) - assembly instructions, syntax errors
• hello.o (Generated by Assembler) - assembly instructions to object code.
• hello (Generated by Linker) - appending bootstrap code, linker assigned the load address to executable

C:

• int main(){
• int main(int argc, char* argv[]){
• int main(int argc, char **argv){

C++:

• int main(){
• int main(int argc, char **argv){
• int main(int argc, char* argv[]){
• main(){

arguments

• argc (ARGument Count) denotes the number of arguments to be passed
• argv [ ] (ARGument Vector) denotes a pointer array pointing to every argument that has been passed to your program.
• argv[0] stores the name of your program - argv[0] to argv[argc-1]
• arguments separate by space

#define LENGTH 10 const int LENGTH = 10;

/ to end of the line /* * - do not nest, can not be inside string or character literal

/usr/src/linux-5.15.80-gentoo/kernel/audit.c

/**
 * auditd_test_task - Check to see if a given task is an audit daemon
 * @task: the task to check
 *
 * Description:
 * Return 1 if the task is a registered audit daemon, 0 otherwise.
 */
int auditd_test_task(struct task_struct *task)
{
        int rc;
        struct auditd_connection *ac;

        rcu_read_lock();
        ac = rcu_dereference(auditd_conn);
        rc = (ac && ac->pid == task_tgid(task) ? 1 : 0);
        rcu_read_unlock();

        return rc;
}

link mylib from /usr/local/lib

gcc -L/usr/local/lib -lmylib

• external linkage - throughout the entire program,
• internal linkage - restricted to one source file
• no linkage respectively - restricted to one function (or perhaps a single compound statement).

1. A declaration outside a function (file scope) which contains the static storage class specifier results in internal linkage for that name. (The Standard requires that function declarations which contain static must be at file scope, outside any block)
2. If a declaration contains the extern storage class specifier, or is the declaration of a function with no storage class specifier (or both), then:
   • If there is already a visible declaration of that identifier with file scope, the resulting linkage is the same as that of the visible declaration;
   • otherwise the result is external linkage.
3. If a file scope declaration is neither the declaration of a function nor contains an explicit storage class specifier, then the result is external linkage.
4. Any other form of declaration results in no linkage.
5. In any one source code file, if a given identifer has both internal and external linkage then the result is undefined.

• Declarations that result in no linkage are also definitions.
• Declarations that include an initializer are always definitions; this includes the ‘initialization’ of functions by providing their body. Declarations with block scope may only have initializers if they also have no linkage.
• Otherwise, the declaration of a name with file scope and with either no storage class specifier or with the static storage class specifier is a tentative definition. If a source code file contains one or more tentative definitions for an object, then if that file contains no actual definitions, a default definition is provided for that object as if it had an initializer of 0. (Structures and arrays have all their elements initialized to 0). Functions do not have tentative definitions.

• For external declarations the default storage class specifier will be extern and for internal declarations it

will be auto.

• declaration of functions - default storage class specifier is always extern.

Higher at top

• arithmetic: +, -, *, /, %
• assignment: =
• augmented assignment: +=, -, *, /=, %=, &=, |=, ^=, <<=, >>=
• bitwise logic: ~, &, |, ^
• bitwise shifts: <<, >>
• boolean logic: !, &&, ||
• conditional evaluation: ? :
• equality testing: =, !
• calling functions: ( )
• increment and decrement: ++, –
• member selection: ., ->
• object size: sizeof
• order relations: <, <=, >, >=
• reference and dereference: &, *, [ ]
• sequencing: ,
• subexpression grouping: ( )
• type conversion: (typename)

if (a = b + 1), which will be evaluated as true if a is not zero after the assignment

• usual arithmetic conversions are implicitly performed to cast their values to a common type.
• Integer Promotion - values of integer type "smaller" than int or unsigned int are converted either to int or unsigned int
• usual arithmetic conversions are not performed for the assignment operators, nor for the logical operators && and ||

Compiler first performs integer promotion; if the operands still have different types, then they are converted to the type that appears highest in the following hierarchy:

1. char
2. unsigned char
3. int
4. unsigned int
5. long
6. unsigned long
7. long long
8. unsigned long long
9. float
10. double
11. long double

inbuilt typecasting functions:

• atof() Converts a string to float
• atoi() Converts a string to int
• atol() Converts a string to long
• itoa() Converts int to string
• ltoa() Converts long to string

https://en.wikipedia.org/wiki/Operator_associativity https://en.wikipedia.org/wiki/Assignment_(computer_science)

• Static memory allocation: space for the object is provided in the binary at compile-time; these objects have an extent (or lifetime) as long as the binary which contains them is loaded into memory.
• Automatic memory allocation: temporary objects can be stored on the stack, and this space is automatically freed and reusable after the block in which they are declared is exited.
  • stack space is typically much more limited and transient than either static memory or heap space
• Dynamic memory allocation: blocks of memory of arbitrary size can be requested at run-time using library functions such as malloc from a region of memory called the heap; these blocks persist until subsequently freed for reuse by calling the library function realloc or free

https://en.wikipedia.org/wiki/C_data_types signed and unsigned

• char
• short
• int
• long
• long long
• float - single-precision floating-point type
• double
• long double
• bool

• all of its data members are stored in contiguous memory locations
• A function may directly return a structure, although this is often not efficient at run-time. Since C99, a structure may also end with a flexible array member.
• initialization: = {0, 1}
• '.' for access by value
• '->' for access by pointer

designated Initialization - initialization in any order (since C99 standard.)

struct Point p1 = { .y = 0, .z = 1, .x = 2 } or only one: struct Point p1 = { .x = 2 }

• is a structure with overlapping members; only the last member stored is valid.
• The memory occupied by a union will be large enough to hold the largest member of the union.
• Последнее присвоение будет хранить корректные данные

• great cost of safety: the program logic must ensure that it only reads the field most recently written along all possible execution paths.

  union [union tag] { member definition; member definition; … member definition;

} [one or more union variables];

store a fixed-size sequential collection of elements of the same type

type arrayName [ arraySize ];

double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0}; # 5 - size
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
int a[10][8];  // array of 10 elements, each of type 'array of 8 int elements'
double balance[5] = {1000.0}

pass to function:

• void myFunction(int *param) - Formal parameters as a pointer
• void myFunction(int param[10]) - Formal parameters as a sized array
• void myFunction(int param[]) - Formal parameters as an unsized array

example with size:

double getAverage(int arr[], int size)

Return from function

• C programming does not allow to return an entire array as an argument to a function.
• C does not advocate to return the address of a local variable to outside of the function, so you would have to define the local variable as static variable.

int * myFunction()

• conventionally implemented as null-terminated character arrays
• one-dimensional array of characters terminated by a null character '\0'.

define:

• char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
• char greeting[] = "Hello";
• ' - for char, " for string

#include <string.h> //string operations

• can be dereferenced to access data stored at the address pointed to, or to invoke a pointed-to function
• Void pointers (void *) point to objects of unspecified type,
• ampersand (&) operator - access address of variable - &a; returns the actual address of the variable.
• *pointer - access variable at pointer
• NULL is a constant with value of zero
  • Dereferencing a null pointer value is undefined - often resulting in a segmentation fault
• sizeof() Returns the size of a variable.

int *ptr[MAX]; // array of pointer to int
char *names[] = { "Zara Ali", "Hina Ali", "Nuha Ali", "Sara Ali" }; // pinters to strings
name[0], name[1]

specifies that no value is available

• Function returns as void
• Function arguments as void - int rand(void) = int rand()
• Pointers to void - represents the address of an object, but not its type
  • void *malloc( size_t size ) - returns a pointer to void which can be casted to any data type.

expression

tupically char or int.

break

exit from switch.

default

statement is optional, and specifies some code to run if there is no case match.

constant-expression

for a case must be the same data type as the variable in the switch, and it must be a constant or a literal.

switch (<expression>) {
case <const-expression-1>:
  <statement>
    break;
case <const-expression-2>:
  <statement>
    break;
case <const-expression-3>: // here we combine case 3 and 4
case <const-expression-4>:
  <statement>
    break;
default:                      // optional
  <statement>

for ( init; condition; increment ) {
   statement(s);
}

• init step is executed first, and only once
• condition - If it is true, the body of the loop is executed
• increment - executed After the body

KeyCode key_codes[] = {
    KEY_HOME,
    KEY_UP,
    KEY_PAGEUP,
    KEY_LEFT,
    KEY_RIGHT,
    KEY_END,
    KEY_DOWN,
    KEY_PAGEDOWN,
    0
  };
  KeyCode *pointer;

  for (pointer = key_codes; *pointer; pointer++) {
    key_info->modifier_mask_or_key_kind[*pointer] = KI_KIND_CURSOR;
  }

• #include <stdarg.h>
• int func(int, … )
• always an int - total number variable arguments passed
• ellipses = …
• va_list valist; // define
• va_start(valist, num); // initialize
• va_arg(valist, int); // get
• va_end(valist); // clean

#include <stdio.h>
#include <stdarg.h>

double average(int num,...) {

   va_list valist;
   double sum = 0.0;
   int i;

   /* initialize valist for num number of arguments */
   va_start(valist, num);

   /* access all the arguments assigned to valist */
   for (i = 0; i < num; i++) {
      sum += va_arg(valist, int);
   }

   /* clean memory reserved for valist */
   va_end(valist);

   return sum/num;
}

int main() {
   printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));
   printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}

typedef int aaa, bbb, ccc; typedef int ar[15], arr[9][6]; typedef char c, *cp, carr[100];

* now declare some objects *

* all ints * aaa int1; bbb int2; ccc int3;

ar yyy; * array of 15 ints * arr xxx; * 9*6 array of int *

c ch; * a char * cp pnt; * pointer to char * carr chry; * array of 100 char *

• Simple Macros - extend the same way
  • #define MAIN
  • #define BUFFER_SIZE 1020
  • #define BAR (x) - 1 / (x) - expand into `(x) - 1 / (x)'
  • Macro definitions do not have to have balanced parentheses.
  • multiline with '\' symbol
• Macros with Arguments
  • #define min(X, Y) ((X) < (Y) ? (X) : (Y))
  • use: `min (1, 2)' and `min (x + 28, *p)'
  • You may not define the same name as both a simple macro and a macro with arguments.
• Stringification - turning a code into a string constant. ex: `foo (z)' results in `"foo (z)"'
  • #define WARN_IF(EXP) fprintf (stderr, "Warning: " #EXP "\n");
• Concatenation - ## operator
• Undefining Macros - #undef FOO - cancel its definition
• `#if', `#ifdef' or `#ifndef
  • `#endif' is final macro, good practice to add comment with #if expression after
  • expression is a C expression of integer type
    • `sizeof' operators and enum-type values are not allowed
  • #else
  • #elif expression
  • #if 0 #endif - good alternative to comment code
  • preprocessor does not understand sizeof, or typedef names, or even the type keywords such as int.
  • special operator `defined' is used in `#if' expressions to test whether a certain name is defined as a macro. Either `defined name' or `defined (name)
• #PREDICATE (ANSWER)
  • Значением ANSWER может быть любая последоватльность слов. Здесь все символы являются значимыми, за исключением пробелов, расположенных в начале и в конце ANSWER
  • Большинство проверяемых утверждений являются заранее определенными.
  • GNU C предоставляет три заранее определенных утверждения: 'system', 'cpu' и 'machine'
    • #system (gnu)
    • #system (mach)
    • #system (unix) – most common
  • deprecated alternative to macros
  • in practice they are just as unpredictable as the system-specific predefined macros. In addition, they are not part of any standard, and only a few compilers support them.
  • To test an assertion, you write it in an `#if'
    • #if #machine (vax)
    • #if #machine - can test whether any answer is asserted for a predicate by omitting the answer in the conditional
  • #assert predicate (answer)
  • You can also make or cancel assertions using command line options.
    • -A predicate=answer Make an assertion with the predicate predicate and answer answer.
    • -A -predicate=answer Cancel an assertion with the predicate predicate and answer answer.
• `#error' causes the preprocessor to report a fatal error. #warning - warning and continue
  • #error Won't work on Vaxen. See comments at get_last_object.
• #line alter the results of the `__FILE__' and `__LINE__' predefined macros from that point on.
  • #line linenum
  • #line linenum filename
  • #line anything else

• #define - Substitutes a preprocessor macro. - constants, functions
• #include - Inserts a particular header from another file.
• #undef - Undefines a preprocessor macro.
• #ifdef - Returns true if this macro is defined.
• #ifndef - Returns true if this macro is not defined.
• #if - Tests if a compile time condition is true.
• #else - The alternative for #if.
• #elif - #else and #if in one statement.
• #endif - Ends preprocessor conditional.
• #error - Prints error message on stderr.
• #pragma - Issues special commands to the compiler, using a standardized method.

Standart

• __DATE__ The current date as a character literal in "MMM DD YYYY" format.
• __TIME__ The current time as a character literal in "HH:MM:SS" format.
• __FILE__ This contains the current filename as a string literal.
• __LINE__ This contains the current line number as a decimal constant.
• __STDC__ Defined as 1 when the compiler complies with the ANSI standard.

Nonstandard

• unix `unix' is normally predefined on all Unix systems.
• BSD `BSD' is predefined on recent versions of Berkeley Unix (perhaps only in version 4.3).

Other nonstandard predefined macros describe the kind of CPU, with more or less specificity. For example,

• vax `vax' is predefined on Vax computers.
• mc68000 `mc68000' is predefined on most computers whose CPU is a Motorola 68000, 68010 or 68020.
• m68k `m68k' is also predefined on most computers whose CPU is a 68000, 68010 or 68020; however, some makers use `mc68000' and some use `m68k'. Some predefine both names. What happens in GNU C depends on the system you are using it on.
• M68020 `M68020' has been observed to be predefined on some systems that use 68020 CPUs–in addition to `mc68000' and `m68k', which are less specific.
• _AM29K_AM29000 Both `_AM29K' and `_AM29000' are predefined for the AMD 29000 CPU family.
• ns32000 `ns32000' is predefined on computers which use the National Semiconductor 32000 series CPU.

Yet other nonstandard predefined macros describe the manufacturer of the system. For example,

• sun `sun' is predefined on all models of Sun computers.
• pyr `pyr' is predefined on all models of Pyramid computers.
• sequent `sequent' is predefined on all models of Sequent computers.

• The Macro Continuation (\) Operator
• The Stringize (#) Operator - may be used only in a macro having a specified argument or parameter list
• The Token Pasting (##) Operator - insert argument to create new one
• The Defined() Operator - to determine if an identifier is defined using #define
• Parameterized Macros

multiple include optimization

File "grandparent.h"

#ifndef GRANDPARENT_H
#define GRANDPARENT_H

struct foo {
    int member;
};

#endif /* GRANDPARENT_H */

https://www.math.utah.edu/docs/info/cpp_1.html

• (1) Small number of functions, perhaps even as little as one.
• (2) No dynamic memory allocations.
• (3) No input or output.
• (4) Define at most one structure, and perhaps even none.

https://nullprogram.com/blog/2018/06/10/

macro:

void assert(int expression);

expression − This can be a variable or any C expression. If expression evaluates to TRUE, assert() does nothing. If expression evaluates to FALSE, assert() displays an error message on stderr (standard error stream to display error messages and diagnostics) and aborts program execution.

for testing and mapping characters.

All the functions return non-zero (true) if the argument c satisfies the condition described, and zero(false) if not.

• int isalnum(int c) This function checks whether the passed character is alphanumeric.
• int tolower(int c) This function converts uppercase letters to lowercase.
• int toupper(int c) This function converts lowercase letters to uppercase.

• defines the integer variable errno, which is set by system calls and some library functions in the event of an error to indicate what went wrong.
• zero - no error
• see 17

#include <stdio.h>
#include <errno.h>
#include <string.h>

extern int errno ;

int main () {
   FILE *fp;

   fp = fopen("file.txt", "r");
   if( fp == NULL ) {
      fprintf(stderr, "Value of errno: %d\n", errno);
      fprintf(stderr, "Error opening file: %s\n", strerror(errno));
   } else {
      fclose(fp);
   }

   return(0);
}

floating-point number is composed of following four elements −

S

sign ( +/- )

b

base or radix of the exponent representation, 2 for binary, 10 for decimal, 16 for hexadecimal, and so on…

e

exponent, an integer between a minimum emin and a maximum emax.

p

precision, the number of base-b digits in the significand.

floating-point = ( S ) p x be
floating-point = (+/-) precision x baseexponent

The following values are implementation-specific. Note that in all instances FLT refers to type float, DBL refers to double, and LDBL refers to long double.

implementation-specific, determines various properties of the various variable types types like char, int and long.

• CHAR_BIT 8 Defines the number of bits in a byte.
• SCHAR_MIN -128 Defines the minimum value for a signed char.
• SCHAR_MAX +127 Defines the maximum value for a signed char.
• UCHAR_MAX 255 Defines the maximum value for an unsigned char.
• CHAR_MIN -128 Defines the minimum value for type char and its value will be equal to SCHAR_MIN if char represents negative values, otherwise zero.
• CHAR_MAX +127 Defines the value for type char and its value will be equal to SCHAR_MAX if char represents negative values, otherwise UCHAR_MAX.
• MB_LEN_MAX 16 Defines the maximum number of bytes in a multi-byte character.
• SHRT_MIN -32768 Defines the minimum value for a short int.
• SHRT_MAX +32767 Defines the maximum value for a short int.
• USHRT_MAX 65535 Defines the maximum value for an unsigned short int.
• INT_MIN -2147483648 Defines the minimum value for an int.
• INT_MAX +2147483647 Defines the maximum value for an int.
• UINT_MAX 4294967295 Defines the maximum value for an unsigned int.
• LONG_MIN -9223372036854775808 Defines the minimum value for a long int.
• LONG_MAX +9223372036854775807 Defines the maximum value for a long int.
• ULONG_MAX 18446744073709551615 Defines the maximum value for an unsigned long int.

location specific settings, such as date formats and currency symbols.

• LC_ALL Sets everything.
• LC_COLLATE Affects strcoll and strxfrm functions.
• LC_CTYPE Affects all character functions.
• LC_MONETARY Affects the monetary information provided by localeconv function.
• LC_NUMERIC Affects decimal-point formatting and the information provided by localeconv function.
• LC_TIME Affects the strftime function.

Library Functions

• char *setlocale(int category, const char *locale) Sets or reads location dependent information.
• struct lconv *localeconv(void) Sets or reads location dependent information.

Library Structure

typedef struct {
   char *decimal_point; // Decimal point character used for non-monetary values.
   char *thousands_sep; // Thousands place separator character used for non-monetary values.
   char *grouping;      // A string that indicates the size of each group of digits in non-monetary quantities. Each character represents an integer value, which designates the number of digits in the current group. A value of 0 means that the previous value is to be used for the rest of the groups.
   char *int_curr_symbol;
   char *currency_symbol;
   char *mon_decimal_point;
   char *mon_thousands_sep;
   char *mon_grouping;
   char *positive_sign;
   char *negative_sign;
   char int_frac_digits;
   char frac_digits;
   char p_cs_precedes;
   char p_sep_by_space;
   char n_cs_precedes;
   char n_sep_by_space;
   char p_sign_posn;
   char n_sign_posn;
} lconv

All the functions available in this library take double as an argument and return double as the result.

• HUGE_VAL - This macro is used when the result of a function may not be representable as a floating point number. If magnitude of the correct result is too large to be represented, the function sets errno to ERANGE to indicate a range error, and returns a particular, very large value named by the macro HUGE_VAL or its negation (- HUGE_VAL). If the magnitude of the result is too small, a value of zero is returned instead. In this case, errno might or might not be set to ERANGE.

Functions:

• double acos(double x) Returns the arc cosine of x in radians.
• etc

These are used in C for exception handling.

variable: jmp_buf - This is an array type used for holding information for macro setjmp() and function longjmp().

macro: int setjmp(jmp_buf environment) - This macro saves the current environment into the variable environment for later use by the function longjmp(). If this macro returns directly from the macro invocation, it returns zero but if it returns from a longjmp() function call, then a non-zero value is returned.

Functions: void longjmp(jmp_buf environment, int value) - Go back to place pointed by buf and return i. This function restores the environment saved by the most recent call to setjmp() macro in the same invocation of the program with the corresponding jmp_buf argument.

https://www.tutorialspoint.com/c_standard_library/

Tracitional C practice is to use lower case for variable names, and all upper case for symbolic constants.

• array - array of data
• type - usualy a enum
• node - link to other nodes
• entity - generic networking thing
• handle - pointer to opaqe data structure
• func - function pointer or function used as function pointer
• internal - function internal to a module
• i, j, k, count, length, found, next, previous, f, vec

https://stackoverflow.com/questions/19983148/fastest-output-to-file-in-c-and-c

%[parameter][flags][width][.precision][length]type

• Type field
• d, i signed int
• u decimal unsigned int
• f, F double - normal (fixed-point) notation
• e, E double value in standard form (d.ddde±dd)
• g, G double in either normal or exponential notation, whichever is more appropriate for its magnitude
• x, X unsigned int as hexadecimal number
• o unsigned int in octal.
• s null-terminated string.
• c char (character).
• p void* (pointer to void) in an implementation-defined format.
• a, A double in hexadecimal notation
• n Print nothing

https://docs.gtk.org/glib/

Dependencies

• GModule Portable API for dynamically loading modules
• GObject The base type system library
• GIO GObject Interfaces and Objects, Networking, IPC, and I/O

an event loop for

• polled file I/O
• event-based widget systems

is a set of sources (or file descriptors (FDs) to check) with an associated callback function which will be invoked when that event is received.

is completely thread safe

At the core GMainContext is just a poll() loop or Event loop - one iteration:

• Prepare sources, determining if any of them are ready to dispatch immediately.
• Poll the sources, blocking the current thread until an event is received for one of the sources.
• Check which of the sources received an event (several could have).
• Dispatch callbacks from those sources.

https://developer.gnome.org/documentation/tutorials/main-contexts.html

• tutorials https://developer.gnome.org/documentation/tutorials.html

We suggest that you use the '-O2' switch in all of your compilations; it increases speed and decreases the program size at the cost of compilation time.

• -Wall All of the above '-W' options combined. This enables all the warnings about constructions that some users consider questionable, and that are easy to avoid (or modify to prevent the warning), even in conjunction with macros.
• -g Produce debugging information in the operating system's native format (stabs is the default for the MC68000). GDB can work with this debugging information. Note that the tigcc frontend defaults to DWARF 2 debugging information instead, see Options Available in the Command Line Compiler. The following options are useful when GCC is generated with the capability for more than one debugging format.
• -O/-O1 With '-O', the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time.
• -O2 Optimize even more.
• -D name or -D name=definition - Predefine name as a macro.

C++ header files:

• `gcc -print-prog-name=cc1plus` -v

C header files:

• `gcc -print-prog-name=cpp` -v

  In addition, gcc will look in the directories specified after the -I option.

pass

• GNU make: an automation tool for compilation and build
• GNU Compiler Collection (GCC): a suite of compilers for several programming languages
• GNU C Library (glibc): core C library including headers, libraries, and dynamic loader
• GNU Binutils: a suite of tools including linker, assembler and other tools
• GNU Bison: a parser generator, often used with the Flex lexical analyser
• GNU m4: an m4 macro processor
• GNU Debugger (GDB): a code debugging tool
• GNU Autotools (GNU Build System): Autoconf, Automake and Libtool

designed to assist in making source code packages portable to many Unix-like systems.

• two-step process: configure followed by make

autoconf - generates a configure script based on the contents of a configure.ac file. The configure script, when run, scans the build environment and generates a subordinate config.status script which, in turn, converts other input files and most commonly Makefile.in into output files (Makefile), which are appropriate for that build environment.

automake - generate Makefile.in as an alternative to configure script, which is used to generate portable Makefile

• performs automatic dependency tracking

Libtool - helps manage the creation of static and dynamic libraries on various Unix-like operating systems. Libtool accomplishes this by abstracting the library-creation process, hiding differences between various systems (e.g. Linux systems vs. Solaris).

• libc++ - implementation of the C++ Standard Library
• LLVM front ends (compiler) - Ada, C, C++, D, Delphi, Fortran, Haskell, Julia, Objective-C, Rust
• Back ends (target platforms) - instruction sets, including IA-32, x86-64, ARM, Qualcomm Hexagon, MIPS, Nvidia Parallel Thread Execution (PTX; called NVPTX in LLVM documentation), PowerPC, AMD TeraScale,[39] most AMD GPU recent ones (called AMDGPU in LLVM documentation),[40] SPARC, z/Architecture (called SystemZ in LLVM documentation), and XCore.
• lld - Linker
• LLDB - Debugger

makefile is a confuguration file for make utility. make utility will determine automatically which pieces of a large program need to be recompiled.

• make -n : dry run
• -k ,tells make to keep going when an error is found
• -f ,which allows you to tell make which file to use as its makefile

targets without Makefile: make -np | grep PHONY

.PHONY: all clean depend install uninstall

• file: CMakeLists.txt.
• License: BSD-3-Clause

Mainly for C++

• a cross-platform tool; the idea is to have a single definition of how the project is built - which translates into specific build definitions for any supported platform.
• On Linux, CMake generates Makefiles; on Windows, it can generate Visual Studio projects, and so on.
• Build behavior is defined in CMakeLists.txt files - one in every directory of the source code
• CMake commands are case insensitive

• #include <assert.h>
• assert(2+2 == 5);

• ddd - graphical interface
• C and C++ programs
• Debugging Symbol Table maps instructions in the compiled binary program to their corresponding variable, function, or line in the source code.
  • gcc -g hello.cc -o hello - debugging option (-g)
• a.out is the default executable name generated by the gcc

dev-util/valgrind

• Generate a callgrind.out.<PID> file.
  • valgrind –tool=callgrind ./main
• generate graph.png using gprof2dot
  • ./gprof2dot.py –format=callgrind –output=out.dot /path/to/callgrind.out
  • dot -Tpng out.dot -o graph.png

The problem is :

1. no built-in test to see if the output is actually what you'd expect
2. you can't change your mind about what is getting printed out without editing the code
3. output can be misleading: in particular, printf output is usually buffered, which means that if your program dies suddenly there may be output still in the buffer that is never flushed to stdout. This can be very confusing, and can lead you to believe that your program fails earlier than it actually does.

solving:

• use assert
• Use fprintf(stderr, …) instead of printf(…); - output to stderr is usually unbuffered
• If you must output to stdout, put fflush(stdout) after
• Keep all arguments passed to printf as simple as possible and beware of faults in your debugging code itself.

Objective-C is a general-purpose programming language that enhances C with the Smalltalk-style messaging.

• for iOS and OS X operating systems for Apple products.
• object-oriented
• Objective-C does not offer multiple inheritance
• C++ uses true and false for bool, while Objective-C works with YES and NO for BOOL.
• Smalltalk messaging paradigm in which you transfer so-called messages to objects through functions or selectors.
• C++ manages structs and classes the same, Objective-C treats them completely differently.
• In theory, Objective-C is slower than C++ because of the dynamic method dispatch.

#include <cstdio> # c library include <stdio.h>

• Encapsulate a resource into a class (constructor)
• Use the resource via a local instance of the class
• The resource is automatically released when the object gets out of scope (restructor)

Implication 1: C++ does not require the garbage collector

Implication 2: The programmer has the responsibility to manage the resource

https://github.com/federico-busato/Modern-CPP-Programming/blob/master/07.Object_Oriented_I.pdf