Programming-Idioms.org

printf("Hello World\n");

for (int i = 0; i < 10; i++) {
    printf("Hello\n");
}

void finish(void) {
    printf("My job here is done.\n");
}

int square(int x){
  return x*x;
}

typedef struct {
  double x;
  double y;
} Point;

for (unsigned int i = 0 ; i < items_length ; ++i){
        Item* x = &(items[i]);
	DoSomethingWith(x);
}

for (size_t i = 0; i < sizeof(items) / sizeof(items[0]); i++) {
	DoSomethingWith(&items[i]);
}

for (size_t i = 0; i < n; i++) {
  printf("Item %d = %s\n", i, toString(items[i]));
}

ENTRY a = {"foo", "twenty"};
ENTRY b = {"bar", "three"};
if (hcreate (23)) {
    hsearch(a, ENTER);
    hsearch(b, ENTER);
}

struct treenode{
  int value;
  struct treenode* left;
  struct treenode* right;
}

srand(time(NULL));
for (int i = 0; i < N-1; ++i)
{
    int j = rand() % (N-i) + i;
    int temp = x[i];
    x[i] = x[j];
    x[j] = temp;
}

x[rand() % x_length];

bool contains(int x, int* list, size_t list_len) {
    for (int i=0 ; i<list_len ; i++)
        if (list[i] == x)
            return true;
    return false;
}

double pick(double a, double b)
{
	return a + (double)rand() / ((double)RAND_MAX * (b - a));
}

int pick(int a, int b)
{
	int upper_bound = b - a + 1;
	int max = RAND_MAX - RAND_MAX % upper_bound;
	int r;

	do {
		r = rand();
	} while (r >= max);
	r = r % upper_bound;
	return a + r;
}

typedef struct node_s
{
    int value;
    struct node_s *nextSibling;
    struct node_s *firstChild;
} node_t;

int *p1 = x;
int *p2 = x + N-1;

while (p1 < p2)
{
    int temp = *p1;
    *(p1++) = *p2;
    *(p2--) = temp;
}

void search(void ***m,void *x,size_t memb_size,int len_x,int len_y,int *i,int *j)
{
	typedef void *m_type[len_x][len_y];
	m_type *m_ref=(m_type*)m;

	for(*i=0;*i<len_x;*i+=1)
	{
		for(*j=0;*j<len_y;*j+=1)
		{
			if(!memcmp((*m_ref)[*i][*j],x,memb_size))
			{
				return;
			}
		}
	}
	*i=*j=-1;
}

a^=b;
b^=a;
a^=b;

b = a + b
a = b - a
b = b - a

int i = atoi(s);

i = (int)strtol(s, (char **)NULL, 10);

sprintf(s, "%.2f", x);

const char * s = "ネコ";

double **x=malloc(m*sizeof(double *));
int i;
for(i=0;i<m;i++)
	x[i]=malloc(n*sizeof(double));

const int m = 2;
const int n = 3;
double x[m][n];

double ***x=malloc(m*sizeof(double **));
int i,j;
for(i=0;i<m;i++)
{
	x[i]=malloc(n*sizeof(double *));
	for(j=0;j<n;j++)
	{
		x[i][j]=malloc(p*sizeof(double));
	}
}

int compareProp (const void *a, const void *b)
{
    return (*(const Item**)a)->p - (*(const Item**)b)->p;
}

qsort(items, N, sizeof(Item*), compareProp);

unsigned int f(unsigned int i)
{
	return i?i*f(i-1):1;
}

unsigned int exp(unsigned int x,unsigned int n)
{
    if(n==0)
    {
        return 1;
    }
    if(n==1)
    {
        return x;
    }
    if(!(n%2))
    {
        return exp(x*x,n/2);
    }
    return x*exp(x*x,(n-1)/2);
}

char *t=malloc((j-i+1)*sizeof(char));
strncpy(t,s+i,j-i);

int ok = strstr(s,word) != NULL;

char *strrev(char *s)
{
	size_t len = strlen(s);
	char *rev = malloc(len + 1);

	if (rev) {
		char *p_s = s + len - 1;
		char *p_r = rev;

		for (; len > 0; len--)
			*p_r++ = *p_s--;
		*p_r = '\0';
	}
	return rev;
}

int *v = a;
while (v < a+N)
{
    int *w = b;
    while (w < b+M)
    {
        if (*v == *w)
            goto OUTER;
        
        ++w;
    }
    printf("%d\n", *v);
    
    OUTER: ++v;
}

int i,j;
for(i=0;i<sizeof(m)/sizeof(*m);i++)
{
	for(j=0;j<sizeof(*m)/sizeof(**m);j++)
	{
		if(m[i][j]<0)
		{
			printf("%d\n",m[i][j]);
			goto end;
		}
	}
}
end:

usleep(5000000);

Sleep(5000);

char *s = "Huey\n"
          "Dewey\n"
          "Louie";

chunks[0] = strtok(s, " ");
for (int i = 1; i < N; ++i)
{
    chunks[i] = strtok(NULL, " ");
    
    if (!chunks[i])
        break;
}

forever {
	// Do something
}

for(;;){
	// Do something
}

while(1){
	// Do something
}

loop:
	goto loop;

#define DELIM ", "
#define L 64

char y[L] = {'\0'};

for (int i = 0; i < N; ++i)
{
    if (i && x[i][0])
        strcat(y, DELIM);
    
    strcat(y, x[i]);
}

int i,s;
for(i=s=0;i<n;i++)
{
	s+=x[i];
}

int sum = 0;
for (int i = 0; i < n; ++i) {
  sum += x[i];
}

char s[0x1000]={};
itoa(i,s,10);

FILE *file;
size_t len=0;
char *lines;
assert(file=fopen(f,"rb"));
assert(lines=malloc(sizeof(char)));

while(!feof(file))
{
	assert(lines=realloc(lines,(len+0x1000)*sizeof(char)));
	len+=fread(lines,1,0x1000,file);
}

assert(lines=realloc(lines,len*sizeof(char)));

int err = 0;
int fd = 0;
void * ptr = NULL;
struct stat st;
if ((fd = open (f, O_RDONLY))
&& (err = fstat (fd, &st)) == 0
&& (ptr = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) != -1) {
    const char * lines = ptr;
    puts (lines);
    munmap (ptr, st.st_size);
    close (fd);
}

fprintf(stderr,"%d is negative\n",x);

void main(int argc, char *argv[])
{
    char *x = argv[1];
}

time_t d=time(0);

int i=(int)(x-strstr(x,y));

char s[7];
sprintf(s, "%.2lf%%", x * 100);

long long binom(long long n, long long k){
  long long outp = 1;
  for(long long i = n - k + 1; i <= n; ++i) outp *= i;
  for(long long i = 2; i <= k; ++i) outp /= i;
  return outp;
}

srand(s);

srand((unsigned)time(0));

int main(int argc, char *argv[])
{
    while (*++argv) {
        printf("%s", *argv);
        if (argv[1]) printf(" ");
    }
    printf("\n");
    return EXIT_SUCCESS;
}

mpz_t _a, _b, _x;
mpz_init_set_str(_a, "123456789", 10);
mpz_init_set_str(_b, "987654321", 10);
mpz_init(_x);

mpz_gcd(_x, _a, _b);
gmp_printf("%Zd\n", _x);

mpz_t _a, _b, _x;
mpz_init_set_str(_a, "123456789", 10);
mpz_init_set_str(_b, "987654321", 10);
mpz_init(_x);

mpz_lcm(_x, _a, _b);
gmp_printf("%Zd\n", _x);

float complex _x = -2 + 3 * I;

_x *= I;

do {
	someThing();
	someOtherThing();
} while(c);

do
{
  stuff()
} while ( c ) ;

float y = (float)x;

int y = (int)x;

int y = (int)floorf(x + 0.5f);

unsigned n;
for (n = 0; s = strstr(s, t); ++n, ++s)
	;

uint32_t c = i;
c = (c & 0x55555555) + ((c & 0xAAAAAAAA) >> 1);
c = (c & 0x33333333) + ((c & 0xCCCCCCCC) >> 2);
c = (c & 0x0F0F0F0F) + ((c & 0xF0F0F0F0) >> 4);
c = (c & 0x00FF00FF) + ((c & 0xFF00FF00) >> 8);
c = (c & 0x0000FFFF) + ((c & 0xFFFF0000) >> 16);

bool addingWillOverflow(int x, int y) {
  return ((x > 0) && (y > INT_MAX - x)) ||
         ((x < 0) && (y < INT_MIN - x));
}

exit (EXIT_SUCCESS);

return 0;

abort();

void *buf = malloc(1000000);

enum {
    E_OK,
    E_OUT_OF_RANGE
};

int square(int x, int *result) {
    if (x > 1073741823) {
        return E_OUT_OF_RANGE;
    }
    *result = x*x;
    return E_OK;
}

void control (void (*f)()) {
        (*f)();
}

FILE *f = fopen(path, "rb");
fseek(f, 0, SEEK_END);
int x = ftell(f);
fclose(f);

struct stat st;
if (stat (path &st) == 0) x = st.st_size;

bool b = !strncmp(s, prefix, sizeof(prefix)-1);

int c(const void *a,const void *b)
{
	int x = *(const int *)a;
	int y = *(const int *)b;

	if (x < y) return -1;
	if (x > y) return +1;
	return 0;
}

int main(void)
{
	int arr[]={1,6,3,7,2};
	qsort(arr,sizeof(arr)/sizeof(*arr),sizeof(*arr),c);

	return 0;
}

#ifdef _WIN32
#define PATH_SEP '\\'
#else
#define PATH_SEP '/'
#endif

int main(int argc, char* argv[])
{
    char *s = strchr(argv[0], PATH_SEP);
    s = s ? s + 1 : argv[0];

    return 0;
}

char *dir = getcwd(NULL, 0);

int main()
{
    char exe[PATH_MAX], real_exe[PATH_MAX];
    ssize_t r;
    char *dir;

    if ((r = readlink("/proc/self/exe", exe, PATH_MAX)) < 0)
      exit(1);
    if (r == PATH_MAX)
	r -= 1;
    exe[r] = 0;
    if (realpath(exe, real_exe) == NULL)
	exit(1);
    dir = dirname(real_exe);
    puts(dir);
}

n = sizeof (t);

bool blank = true;
for (const char *p = s; *p; p++) {
	if (!isspace(*p)) {
		blank = false;
		break;
	}
}

int system("x a b");

size_t n = sizeof(x)/sizeof(*x);

int n;
int x[5];
n = sizeof(x)/sizeof(*x);

int n;
scanf("%d", &n);

int n[15];
fgets(n, 15, stdin);

enum Suit {
    SPADES,
    HEARTS,
    DIAMONDS,
    CLUBS
};

assert(isConsistent());

typedef struct {
    const char * const a;
    const bool b;
} RetStringBool;

RetStringBool foo() {
    return (RetStringBool) {.a = "Hello", .b = true};
}

void foo()
{
#include "foobody.txt"
}

if (c1)
{
    f1();
} 
else if (c2)
{
    f2();
}
else if (c3)
{
    f3();
}

char b = 0;
int n = strlen(s);
for (int i = 0; i < n; i++) {
	if (! (b = (s[i] >= '0' && s[i] <= '9')))
		break;
}

bool b = true;
const int n = strlen(s);
for (int i = 0; i < n; ++i) {
  if (!isdigit(s[i])) {
    b = false;
    break;
  }
}

const char tmpl[] = "XXXXXX.tmp";
int fd = mkstemp(tmpl);

char s[32];
snprintf(s, sizeof(s), "%x", i);

bool b = access(_fp, F_OK) == 0

char s[2] = {0};
s[0] = c;

int main(void)
{
	if (unlink(filepath) == -1)
		err(1, "unlink");
	return 0;
}

const char *_planet = "Earth";

for(int i = 0; i < elements_size; ++i) elements[i] *= c;

int main(int argc, char * argv[])
{
        int optch;
        while ((optch = getopt(argc, argv, "bf")) != -1) {
                switch (optch) {
                        case 'b': bat(); break;
                        case 'f': fox(); break;
                }
        }
        return 0;
}

for (unsigned i = 0; i < sizeof(list) / sizeof(list[0]); i += 2)
	printf("%d, %d\n", list[i], list[i + 1]);

int length = sizeof(items) / sizeof(items[0]);
int x = items[length - 1];

size_t l = strlen(p);
const char * t = strncmp(s, p, l) ? s : s + l;

setlocale(LC_ALL, "");
printf("%'d\n", 1000);

char *s = calloc(n * 2 + 1, 1);
for(int i = 0; i < n; ++i){
  char temp[3];
  sprintf(temp, "%02x", a[i]);
  s[2 * i] = temp[0];
  s[2 * i + 1] = temp[1];
}

const char* hexstring = "deadbeef";
size_t length = sizeof(hexstring);
unsigned char bytearray[length / 2];

for (size_t i = 0, j = 0; i < (length / 2); i++, j += 2)
	bytearray[i] = (hexstring[j] % 32 + 9) % 25 * 16 + (hexstring[j+1] % 32 + 9) % 25;

int isInsideRect(double x1, double y1, double x2, double y2, double px, double py){
	return px >= x1 && px <= x2 && py >= y1 && py <= y2; 
}

struct dirent ** x = NULL;
int n = scandir (p, &x, NULL, alphasort);

int main(){char*s="int main(){char*s=%c%s%c;printf(s,34,s,34);return 0;}";printf(s,34,s,34);return 0;}

main(p){printf(p="main(p){printf(p=%c%s%1$c,34,p);}",34,p);}

exit(EXIT_SUCCESS);

void foo(double *a, int n);
double a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
foo (a, sizeof(a)/sizeof(*a));

unsigned i;
for (i = 0; i < sizeof(a) / sizeof(a[0]); ++i) {
	if (a[i] > x) {
		f();
		break;
	}
}

exit(x);

  double d = 3.14;
  double res;
  int e;

  res = frexp(d, &e);
  printf("%f %d\n",res,e);

const char * foo = getenv("FOO");
if (foo == NULL) foo = "none";

  for (i=0; i<n; i++)
    a[i] = e*(a[i]+b[i]*c[i]+cos(d[i]);

int c = a ^ b;

x = condition() ? "a" : "b";

for (int i = 5; i >= 0; i--) {
	printf("%d\n", i);
}

int t = -1;
if (n)
        while (! (n & 1<<++t));
else
        t = 8*sizeof(n);

char *s = calloc(strlen(v) * n + 1, 1);
for(int i = 0; i < n; ++i) strcat(s, v);

unsigned char *a = calloc(strlen(s) / 8, 1);
for(int i = 0; i < strlen(s); ++i){
  a[i / 8] |= (s[i] == '1') << (7 - i % 8);
}

int *a = calloc(n, sizeof(*a));

// This is a comment.

char s[32] = "";
sprintf(s, "Our sun has %i planets", x);

printf("%f %f", pow(a, b), pow(a, n));

int i = strtol(s, NULL, b);

rename(path1, path2);