g 以及gcc的区别 - C语言例子一 - 《李俊扬的技术分享》

printf 输出格式符
hello world
include

printf 输出格式符

hello world

gcc example.c // 会生成a.out文件
./a.out // 运行 ```c
include

int main() { int i; unsigned short _short = 10; // 无符号短整型 long _long = 1000; float _float = 1.2; double _double = 2.2;

printf(“%d\n”, _short); printf(“%ld\n”, _long); printf(“%f\n”, _float); printf(“%f\n”, _double);

int arr[5] = {1,2,3,4,5}; int array[2][3] = {{1,2,3}, {1,2,3}}; int list[][3] = {{1,2,3}, {1,2,3}}; // sizeof() 长度 = 求对象占用内存 / sizeof(int) int length = sizeof(arr) / sizeof(int); for (i = 0; i < length; i++) { printf(“%d\n”, arr[i]); }

for (i = 0; i < 10; i++) { printf(“%d\n”, i); }

char str[] = {‘a’, ‘b’, ‘c’}; char strA[] = “hello world”;

printf(“%s\n”, str); printf(“%s\n”, strA);

return 0; }

<a name="SQZhd"></a>
## 宏编译
```c
#include <stdio.h>
#define PI 3.1415926 // 定义宏 PI
#define MAX(m,n) (m>n) ? m : n // 定义一个带参数的宏
/**
 * 求圆的周长
*/
float func(float r) {
  return 2 * PI * r;
}
#undef PI // 终止PI的作用域
int main()
{
  printf("%f\n", func(20));
  printf("%d\n", MAX(1, 2));
  printf("Please input two integers:");
  int i, j, max;
  scanf("%d%d", &i, &j);
  max = MAX(i, j);
  printf("max: %d\n", max);
  return 0;
}

条件编译

#include <stdio.h>
#define X 10
int main()
{
  int i = 0;
#if X * 2
  printf("X != 0; X = %d\n", X);
  i = X;
#else
  printf("X = 0;\n");
#endif
// 注意，条件编译不是运行时的，所以i==0
#if i == 0
  printf("i=0\n");
#elif i == 10
  printf("i=10\n");
#else
  printf("i=???\n");
#endif
#ifdef X // #ifdef 判断宏是否被定义
  printf("X宏被定义\n");
#else
  printf("X宏未被定义\n");
#endif
#ifndef X // #ifndef与ifdef逻辑相反 判断宏是否被定义
  printf("X宏未被定义\n");
#else
  printf("X宏被定义\n");
#endif
  return 0;
}

指针的基本使用

#include <stdio.h>
// 注意，指针，或指向指针的指针，都只能保存一个"变量的内存单元"的地址，不存在一个指针可以指向一个数组的情况，
// 因为那就相当于一个指针指向一组变量的内存单元的地址了。
// * 运算符 它会取得指针指向的内容
// & 运算符 他会取得变量的指针
int main()
{
  int i;
  // 定义指针变量
  int *p;
  p = &i;
  i = 1;
  printf("%d %d\n", i, *p);
  *p = 2;
  printf("%d %d\n", i, *p);
  // 初始化可以赋值字符串
  char *str = "hello world";
  printf("%s\n", str);
  /*
    char *strA;
    warning: incompatible pointer to integer conversion assigning to 'char' from 'char [6]'
    *strA = "hello"; // 会抛出异常
    printf("%s\n", strA);
  */
  char *strA;
  char strB[] = "hello world";
  int length = length = sizeof(strB) / sizeof(char);
  strA = &strB[0];
  int j;
  for (j = 0; j < length; j++) {
    printf("%c", *strA);
    strA++;
    if (j + 1 == length) {
      printf("\n");
    }
  }
  printf("%c", *strA);
  char c = 'A';
  // *pp 与 &c 的类型都是 (char *)
  char *pp = &c;
  printf("%d %c\n", (int)c, *pp);
  return 0;
}

指向指针的指针

#include <stdio.h>

// 注意，指针，或指向指针的指针，都只能保存一个"变量的内存单元"的地址，不存在一个指针可以指向一个数组的情况，
// 因为那就相当于一个指针指向一组变量的内存单元的地址了。

// * 运算符 它会取得指针指向的内容
// & 运算符 他会取得变量的指针
int main()
{
  int x, y;
  int *p;
  int **pp;
  p = &x;
  pp = &p;
  **pp = 6;

  printf("%d %d %d\n", x, *p, **pp);
  return 0;
}

指针与数组

#include <stdio.h>

// 注意，指针，或指向指针的指针，都只能保存一个"变量的内存单元"的地址，不存在一个指针可以指向一个数组的情况，
// 因为那就相当于一个指针指向一组变量的内存单元的地址了。

// * 运算符 它会取得指针指向的内容
// & 运算符 他会取得变量的指针
int main()
{
  int arr[3] = {0,1,2};
  int *p;
  // 将arr的首地址赋值给指针p
  p = arr;
  if (p == arr) {
    printf("p 与 arr的首地址相同\n");
  }
  // 将arr的首地址赋值给指针p，与上面的代码效果一致
  p = &arr[0];

  if (p == arr) {
    printf("p 与 arr的首地址相同\n");
  }

  // p+n; 与 arr+n; 都表示 &arr[n]
  // *(p+2) 与 *(arr+2) 都相当于 arr[n]
  printf("%d %d\n", *(p+2), *(arr+2));

  return 0;
}

指针的集合—指针数组

#include <stdio.h>

// 注意，指针，或指向指针的指针，都只能保存一个"变量的内存单元"的地址，不存在一个指针可以指向一个数组的情况，
// 因为那就相当于一个指针指向一组变量的内存单元的地址了。

// * 运算符 它会取得指针指向的内容
// & 运算符 他会取得变量的指针
int main()
{
  char *week[] = {"abc","def"};

  // 这个会报错 error: array initializer must be an initializer list or string literal
  // 数组初始值设定项必须是初始值设定项列表或字符串文字
  // char weekA[4] = week[0];

  printf("%s\n", week[0]); // abc
  return 0;
}

全局函数(外部函数)


// main.c
#include <stdio.h>
// 声明才能使用
extern int hello(char *str, int length);

int main()
{
  char str[] = "hello world!";
  helloStr = &str;
  hello(str, sizeof(str) / sizeof(char));

  return 0;
}

// hello.c
#include <stdio.h>
extern int hello(char *str, int length) {
  int i;
  char strMsg[length];
  for (i = 0; i < length; i++) {
    printf("%c" , *(str+i));
    strMsg[i] = *(str + i);
  }
  printf("\n");
  printf("%s\n", strMsg);
  return 0;
}

内部函数

#include <stdio.h>
static void func() {
  printf("只能在当前文件中使用\n");
}

int main() {
  func();
  return 0;
}

static 变量

#include <stdio.h>
extern int hello(char *str, int length);
void func();
int main()
{
  // auto int i; 自动变量 简写 int i;
  func();
  func();
  // 寄存器变量，比较快
  register int i = 9;
  printf("%d\n", i);
  return 0;
}

void func() {
  int i = 0;
  // 静态变量，函数执行完毕之后，变量并不会销毁，值还在
  static int n = 0;
  i++;
  n++;
  printf("%d\n", i);
  printf("%d\n", n);
}

函数指针

#include <stdio.h>
void func(int i);

int main()
{
  int x = 6;
  // 函数指针
  void (*p)(int);
  p = &func;

  (*p)(x);
  return 0;
}

void func(int i) {
  printf("%d\n", i);
}

类型别名

#include <stdio.h>
// typedef关键字, 您可以使用它来为类型取一个新的名字
typedef int (*FunType)(int, int);
int add(int, int);
int sub(int, int);

void func(FunType, int, int);
int main() {
  func(add, 10, 10);
  func(add, 10, 5);
  return 0;
}
int add(int x, int y) {
  return x + y;
}
int sub(int x, int y) {
  return x - y;
}
void func(FunType p, int x, int y) {
  printf("%d\n", (*p)(x, y));
}

结构体

#include <stdio.h>

void func(int i);
struct address
{
  char province[100]; /**省*/
  char city[100];     /**省*/
  char area[100];     /**省*/
};

struct student {
  int id; /**学号*/
  char name[20]; /**姓名*/
  char sex;      /**性别*/
  unsigned int age; /**年龄*/
  struct address addressInfo; /**地址*/
};
/*
struct student {
  int id;  
char name[20];               
char sex;                   
unsigned int age;           
struct address addressInfo;  
} a; 定义结构体，并声明一个变量
// 初始化数据
a = {1314, "lijunyang"}
*/

int main()
{
  struct student studentObj = {1314};
  struct student *p;
  p = &studentObj;
  func(studentObj.id);
  func(p->id);
  studentObj.id = 520;
  func(studentObj.id);

  char province[] = "浙江";
  int length = sizeof(province) / sizeof(char);
  int i = 0;
  printf("%d\n", length); // 7
  for (i = 0; i < length; i++) {
    printf("%c\n", province[i]);
    studentObj.addressInfo.province[i] = province[i];
  }

  printf("%s\n", studentObj.addressInfo.province);
  return 0;
}

void func(int i) {
  printf("%d\n", i);
}

共用体

#include <stdio.h>

// 共用体，共用一个内存块
union unionObj {
  char s[4];
  char c;
  int i;
  double d;
};

void func(union unionObj, char);

int main()
{
  union unionObj u;
  char str[4] = "A";
  int i;
  int length = sizeof(str) / sizeof(int);
  for (i = 0; i < length; i++) {
    u.s[i] = str[i];
  }

  func(u, 's');
  u.i = 10;
  func(u, 'i');
  u.d = 0.1;
  func(u, 'b');
  // 注意'a'和"a"不一样长度
  u.c = 'a';
  func(u, 'c');
  return 0;
}

void func(union unionObj n, char str)
{
  if (str == 'c') {
    printf("%c\n", n.c);
  } else if (str == 's') {
    printf("%s\n", n.s);
  } else if (str == 'i') {
    printf("%d\n", n.i);
  } else {
    printf("%.2f\n", n.d);
  }
}

枚举

#include <stdio.h>

void func(int i) {
  printf("%d\n", i);
}

// 枚举声明
enum week
{
  A, // 默认从0开始排起，如果下一个值没有给值的话，会自动+1
  B,
  C,
  D
};
enum options
{
  Q = 1,
  W, // W 从 Q 的基础上+1，所以是2
  E = 10,
  R // R 从 E的基础上+1，所以是11
};

int main()
{
  enum week x, y;
  enum options q, w, e, r;
  x = A;
  y = D;
  func(x); // 0
  func(y); // 3
  q = Q;
  w = W;
  e = E;
  r = R;
  func(q); // 1
  func(w); // 2
  func(e); // 10
  func(r); // 11

  return 0;
}

string.h

#include <stdio.h>
#include <ctype.h>

int main()
{
  char str[] = "a1b2c3&HC";
  int len = sizeof(str) / sizeof(char);
  int i;

  for (i = 0; i < len; i++)
  {
    // int isalpha(char s) 判断s是否是字母
    if (isalpha(str[i])) {
      printf("%c\n", str[i]);
    }
  }

  for (i = 0; i < len; i++)
  {
    // int isdigit(char s) 判断s是否是数字
    if (isdigit(str[i]))
    {
      printf("%d\n", (int)str[i]);
    }
  }

  int tempString;
  for (;;) {
    tempString = getchar();
    printf("%c : %s digit\n", tempString, isdigit(tempString) ? "is" : "not");
    printf("%d\n", (int)tempString);
  }

  return 0;
}

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

int main()
{
  char str[] = "a1b2c3&HC";
  int len = sizeof(str) / sizeof(char);
  char des[len];
  // copy 字符串
  strcpy(des, str);

  printf("length=%d, content=%s\n", len, str);

  return 0;
}

动态分配内存

#include <stdio.h>
#include <stdlib.h> /*包含相关函数的头文件*/

int main()
{
  // void *alloca(unsigned size) // 从栈空间中分配，函数返回时内存空间自动释放
  // void *malloc(unsigned size) // 用户必须手动释放内存
  /* 
    用来分配nmemb个相邻的内存单位，每个单位的大小由size来决定，
    与malloc的区别是malloc会将所分配的内存空间初始化为0，而后者则不进行初始化
    void *calloc(size_t nmemb, size_t size);
  */
  // 上面三个方法，如果调用成功，返回所分配的内存空间的首地址，否则返回NULL
  // void free(void *ptr); 释放内存
  // void *reallop(void *ptr, size_t size); // 修改内存空间大小

  int *p;
  int i, tol;
  int SIZE = 5;
  p = (int *)malloc(SIZE * sizeof(int));
  if (p == NULL)
  {
    printf("内存分配失败");
  }
  else
  {
    tol = 0;

    for (i = 0; i < SIZE; i++)
    {
      p[i] = i; // *(p+i) 等价于 p[i] = i
      tol += p[i];
    }

    printf("%d \n", tol);
    printf("----%d %d \n", p[4], *p); // ----4
    p = (int *)realloc(p, 10);
    printf("----%d %d \n", p[4], *p); // ----0 数据丢失
    for (i = 0; i < 10; i++)
    {
      printf("%d-%d\n", i, p[i]);
    }

    if (0 == '\0')
    {
      printf("0 === \'\\0\' \n"); // 这里被打印
    }

    free(p); // 释放内存空间
  }

  return 0;
}

argv

#include <stdio.h>

int main(int argvLength, char *argv [])
{
  int i;
  for (i = 0; i < argvLength; i++) {
    printf("%s\n", argv[i]);
  }

  // 输入 ./a.out abc 666 -c -b
  /*输出
    ./a.out
    abc
    666
    -c
    -b
  */
  return 0;
}

环境变量

#include <stdio.h>
#include <stdlib.h>

int main(int argvLength, char *argv[])
{
  char *p;
  // 获取环境变量
  p = getenv("PATH");
  if (p == NULL) {
    printf("获取环境变量失败");
    return 0;
  }

  printf("PATH=%s\n", p);
  // 设置环境变量
  // ABC=555 =号左右不能有空格
  // 设置环境变量成功返回0，否则返回-1，并设置相应的错误码
  int flag = putenv("ABC=555");

  if (flag == 0) {
    p = getenv("ABC");
    printf("ABC=%s\n", p);
  }

  // int setenv(const char *name, const char *value, int overwrite);
  // overwrite设置为非0值时，如果该环境变量已存在，则使用value进行替换；否则忽略参数value

  setenv("ABC", "666", 1);
  p = getenv("ABC");
  printf("ABC=%s\n", p);

  setenv("ABC", "777", 0); // 不会变化
  p = getenv("ABC");
  printf("ABC=%s\n", p);

  return 0;
}

时间

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>

int main(int argc, char **argv) {
  struct timeval time_val; // 保存时间信息
  struct timezone time_zone; // 保存时区信息

  // 返回1970年1月1日0时0分0秒到现在的秒数
  // time_t time(time_t *t); // 发生错误返回-1，并设置相应的错误码

  // 获取时间和日期
  // in gettimeofday(struct timeval *tv, struct timezone *tz);

  gettimeofday(&time_val, &time_zone);

  printf("输出秒数=%ld\n", time_val.tv_sec); // 输出秒数=1639740112
  printf("输出微秒数=%d\n", time_val.tv_usec); // 输出微秒数=948154

  time_t tim;
  time(&tim);

  // char * ctime(const time_t *timep); // 返回常用时间格式
  printf("%s\n", ctime(&tim));

  // struct tm *gmtime(const time_t *timep);
  struct tm *p;

  char *week[] = {
      "Sunday",    // 星期天 [ˈsʌndeɪ]
      "Monday",    // 星期一 [ˈmʌndeɪ]
      "Tuesday",   // 星期二 [ˈtuːzdeɪ]
      "Wednesday", // 星期三 [ˈwenzdeɪ]
      "Thursday",  // 星期四 [ˈθɜːrzdeɪ]
      "Friday",    // 星期五 [ˈfraɪdeɪ]
      "Saturday"   // 星期六 [ˈsætərdeɪ]
  };

  p = gmtime(&tim);

  // char * asctime(const time_t *timep); // 和ctime功能类似，不过它接受tm格式
  printf("%s\n", asctime(p));

  printf("输出日期=%d-%d-%d\n", (1900+p->tm_year), (1+p->tm_mon), p->tm_mday);
  printf("输出星期=%s\n", week[p->tm_wday]);
  printf("输出时间=%d:%d:%d\n", p->tm_hour, p->tm_min, p->tm_sec);

  return 0;
}

计算执行时间

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>

int main(int argc, char **argv) {
  time_t start;
  time_t end;
  int i, j;
  int *p;
  double res;
  int SIZE = 100000;
  time(&start);

  for (i = 0; i < 90000; i++) {
    p = (int *)malloc(SIZE * sizeof(int));
    for (j = 0; j < SIZE; j++) {
      *(p+j) = j;
    }
    free(p);
  }
  time(&end);

  // double difftime(time_t t1, time t0);
  res = difftime(end, start);
  printf("%f\n", res);
  printf("%s\n", ctime(&start));
  printf("%s\n", ctime(&end));
  return 0;
}