C 语言基础

int 类型

  1. int 的几种类型:short intintlong int,还有对应的无符号,intlong int 的字节数相同

  2. sizeof(short int):查询 short int 的字节数

  3. int类型的数字范围是 +0 和 -0 的补码,由于 -0 的补码被当做最小值,所以负值比正值多了一个数,即 -2^{31} \sim 2^{31}-1 (2^{31}-1 = 2147483647)

  4. 不同 int 类型对应的输出符号,比如 %d 对应 int%llu 对应 long long unsigned int,无符号的都是 %u%x 对应16进制,%o 对应八进制

#include <stdio.h>
#include <limits.h>

int main() {
  short short_int = 0;
  int i = 100;
  long long_int = 0;
  long long longlong_int = 0;
  unsigned int unsigned_int = 123;
  unsigned long unsigned_long = 111;

  printf("short int %d\n", short_int);    // short int 0
  printf("int in oct: %o\n", i);    // int in oct: 144

  // d = decimal
  // x = hex
  // o = oct
  // hd%: short decimal
  // %d: decimal
  // %ld: long decimal
  // %lld: long long decimal
  // %hu: unsigned short decimal
  // \n: new line
  // size_t
  size_t size_of_int = sizeof(int);
  printf("short int: %d\n", sizeof(short int));    // short int: 2
  printf("int: %d\n", sizeof(int));    // int: 4
  printf("long int: %d\n", sizeof(long int));    // long int: 4
  printf("long long: %d\n", sizeof(long long int));    // long long: 8

  printf("max int %d, min %d\n", INT_MAX, INT_MIN);    // max int 2147483647, min -2147483648
  printf("max int %ld, min %ld\n", LONG_MAX, LONG_MIN);    // max int 2147483647, min -2147483648
  printf("unsigned max int %u, unsigned min %d\n", UINT_MAX, 0);    // unsigned max int 4294967295, unsigned min 0
  return 0;
}

char 类型

#include <stdio.h>
#include <limits.h>

int main() {

  char a = 'a';
  char char_1 = '1';
  char i = 0;

  // 按字符集 ASCII 127,打印出来
  printf("char a: %d\n", a);    // char a: 97
  printf("char 1: %d\n", char_1);    // char 1: 49
  printf("char 'i': %d\n", i);    // char 'i': 0

  // 字面量 literal
  // \n : newline
  // \b : backspace
  // \r : return
  // \t : table
  // \' : ' 字符字面量
  // \" : " 字符串字面量
  char char_1_escape_oct = '\61';
  char char_1_escape_hex = '\x31';

  printf("char 1: %c\n", char_1);    // char 1: 1
  printf("char 1: %c\n", char_1_escape_oct);    // char 1: 1
  printf("char 1: %c\n", char_1_escape_hex);    // char 1: 1

  // Unicode  CJK(中文,日语,韩文) Code point.
  // C95 开始,增加了宽字符
  wchar_t zhong = L'中';    // 把汉字转化为 unicode 编码,实质上是 unsigned short,存入变量 zhong,所以是两个字节
  wchar_t zhong_hex = L'\u4E2D';    // '中'字符 Unicode 编码对应的 16 进制

  printf("中:%d\n", zhong);    // 中:20013
  printf("中:%d\n", zhong_hex);    // 中:20013

  return 0;
}

float 和 double 类型

#include <stdio.h>

int main() {
  float a_float = 3.14f; // 需要保持 6 位有效数字, 数值范围在 (+-)10^-37 ~ 10^37
  printf("size of float: %d\n", sizeof(float));    // 具体占的字节大小由编译器决定,此处占 4 个字节

  double a_double = 3.14; // 15~16 位有效数字
  printf("size of double: %d\n", sizeof(double));   // 8 个字节

  float lat = 39.90815f;
  printf("%f", 39.908156f - lat);    //  0.000008,前 7 位精准的

  float money = 3.14f; // 千万不要用 float 或 double 来描述货币

  return 0;
}

数值 12369 可以表示为科学记数法形式 1.2369e4,其中“1”是隐含的符号位,它默认为 1,因而在存储时不占用额外的位。指数部分占用 8 位,其值的范围从 -127 到 128,用于调整尾数的权重。尾数部分则由 23 位组成,它存储了数值的实际小数部分,从而确保了数值的精确度。

符号 尾数 指数
1 23 8
+- 小数部分,决定精度 -127~128,决定范围

变量

#include <stdio.h>
#include <limits.h>

int main() {
  // <type> <name>;
  int value;

  // <type> <name> = <initialized value>
  int value_init = 3;

  value = 4;

  printf("value: %d\n", value);    // value: 4
  printf("size of value: %d\n", sizeof(value));    // size of value: 4
  printf("address of value: %#x\n", &value);    // address of value: 0x61ff10

  // key words 标识符 identifier,变量命名规范
  // 1. a-zA-Z0-9_
  // 2. 数字不能在第一位
  // 3. Google code style, a-z_a-z, person_name
  float a_float3 = 3.14f;
  float a_float = 3.14f;
  return 0;
}

常量

  1. 在编程中,若需声明一个不可通过常规方法修改的变量,可采用const关键字,例如声明一个整型常量const int immutableValue = 0;。尽管该值本身不可变,但若通过指针操作,其指向的内存地址中的数据仍可被更改。
  2. 为了创建一个在代码中完全不可更改的值,可以使用预处理指令#define来定义一个宏常量,如#define HEX_CODE_RED 0xFF0000,这样定义的常量在整个程序中都是唯一的,且不可变。
  3. 如果需要在代码的某个部分取消之前定义的宏,可以使用#undef指令,例如#undef HEX_CODE_RED,执行此操作后,相应的宏定义将不再有效。
  4. 避免在代码中硬编码值,如直接将十六进制颜色值赋给变量int hardcodedColor = 0x00FF00;,这会降低代码的灵活性。相反,应使用宏定义来提高可维护性,例如int dynamicColor = COLOR_GREEN;,这样可以通过修改宏定义来轻松更改颜色值。
#include <stdio.h>

#define COLOR_RED 0xFF0000
#define COLOR_GREEN 0x00FF00
#define COLOR_BLUE 0x0000FF

int main() {
  // const <type> readonly variable
  const int kRed = 0xFF0000;
  const int kGreen = 0x00FF00;
  const int kBlue = 0x0000FF;
  printf("kRed: %d\n", kRed);    // kRed: 16711680

  // 利用指针进行 const 只读常量的修改
  int *p_k_red = &kRed;
  *p_k_red = 0;
  printf("kRed: %d\n", kRed);    // kRed: 0

  // macro
  printf("COLOR_RED: %d\n", COLOR_RED);    // COLOR_RED: 16711680

#undef COLOR_RED    // 取消定义的宏,后续不可使用 COLOR_RED

  // 字面量 literal,宏定义就相当于这个
  3;
  3u;
  3l;
  3.f;
  3.9;
  'c';
  "cs";
  L'中';
  L"中国";

  // 硬编码 hard code
  int background_color_hard = "0x00FF00";
  int background_color = COLOR_GREEN;
  return 0;
}

运算符

四则运算符

#include <stdio.h>

int main() {
  int first = 1;
  int second;
  int third;

  // =
  third = second = first;
  printf("%d, %d\n", second, third);    // 1, 1

  int left, right;
  left = 2;
  right = 3;

  int sum;
  sum = left + right; // 5
  int diff = left - right; // -1
  int product = left * right; // 6
  int quotient = left / right; // 0
  float quotient_float = left / right; // 0.000000
  float quotient_float_correct = left * 1.f / right; // 0.666666....
  int remainder = left % right; // 2

  int quotient_1 = 100 / 30; // 3

  printf("sum: %d\n", sum);
  printf("diff: %d\n", diff);
  printf("product: %d\n", product);
  printf("quotient: %d\n", quotient);
  printf("quotient_1: %d\n", quotient_1);
  printf("quotient_float: %f\n", quotient_float);
  printf("quotient_float_correct: %f\n", quotient_float_correct);
  printf("remainder: %d\n", remainder);

  // > < >= <= == !=
  // true: 1, false: 0
  printf("3 > 2: %d\n", 3 > 2);    // 1
  printf("3 < 2: %d\n", 3 < 2);    // 0
  printf("3 <= 3: %d\n", 3 <= 3);  // 1
  printf("3 >= 3: %d\n", 3 >= 3);  // 1
  printf("3 == 3: %d\n", 3 == 3);  // 1
  printf("3 != 3: %d\n", 3 != 3);  // 0

  // && 与 || 或
  printf("3 > 2 && 3 < 2: %d\n", 3 > 2 && 3 < 2);    // 0
  printf("3 > 2 || 3 < 2: %d\n", 3 > 2 || 3 < 2);    // 1

  // ++ --
  int i = 1;
  int j = i++; // j = 1, i = 2;
  int k = ++i; // k = 3, i = 3;

  printf("i: %d\n", i);
  printf("j: %d\n", j);
  printf("k: %d\n", k);
}

位运算

#include <stdio.h>

int main() {

  // bit operators & | ^ ~
#define FLAG_VISIBLE 0x1 // 2^0, 0001, 是否可见
#define FLAG_TRANSPARENT 0x2 // 2^1, 0010, 是否透明
#define FLAG_RESIZABLE 0x4 // 2^2, 0100, 是否可以改变大小

  int window_flags = FLAG_RESIZABLE | FLAG_TRANSPARENT; // 0110, 定义一个窗口可以改变大小,也可以设置透明

  int resizable = window_flags & FLAG_RESIZABLE; // 0100, 此处为前端去获取后端传来的 window_flags 值,做一个与操作,看是否可以设置窗口大小
  int visible = window_flags & FLAG_VISIBLE; // 0000, 是否可以设置可见

  // << >>, 一种新的定义方式,和上面效果相同
#define FLAG_VISIBLE 1 << 0 // 2^0, 0001, 1 向左移 0 位
#define FLAG_TRANSPARENT 1 << 1// 2^1, 0010, 1 向左移 1 位
#define FLAG_RESIZABLE 1 << 2 // 2^2, 0100, 1 向左移 2 位

#define FLAG 1 << 0
  printf("FLAG: %d \n", FLAG);    // 1, 直接定义当做整数使用便好,只是定义方式不同

  int x = 1000;
  x * 2;
  x << 1;

  x / 2;
  x >> 1;

  //
  x *= 2; // x = x * 2;
  x /= 2; // x = x / 2;
  x += 2;
  x -= 2;
  x %= 2;

  x >>= 1; // x = x >> 1
  x <<= 1; // x = x << 1

  x = 1;
  printf("x: %d\n", x);  // 1

  // ,
  int y = -1;
  int z = (y = x = x * 2, x = x + 3); // 逗号运算符,此句最后的结果是逗号后面的表达式的值

  printf("x: %d\n", x); // 5
  printf("y: %d\n", y); // 2
  printf("z: %d\n", z); // 5
}

条件分支语句

布尔类型

在C语言编程中,布尔类型(bool)是一种特殊的数据类型,它通过包含头文件 #include <stdbool.h> 引入。布尔类型有两种表示形式:_Boolbool。布尔类型的核心特性是它的值只区分两种状态:真(true)和假(false)。在布尔逻辑中,任何非零值都被视为真,而零值则代表假。对于一个初始为真的布尔变量,只有当其被赋值为零时,其状态才会转变为假;其他任何赋值操作都会保持其为真状态。相应地,对于一个初始为假的布尔变量,任何非零的赋值都会将其状态转变为真。

# include <stdio.h>
# include <stdbool.h>

void TestBool() {
  // C 语言中的 bool 类型
  _Bool is_enabled = true;
  printf("is_enabled: %d\n", is_enabled);  // is_enabled: 1

  is_enabled = -10; // 结果为 true 的值不会被改变
  printf("revised is_enabled: %d\n", is_enabled);  // revised is_enabled: 1

  is_enabled = 0; // 结果为 true 只有赋值为 0 时,其值才会变化
  printf("revised is_enabled: %d\n", is_enabled);  // revised is_enabled: 0

  bool is_visible = false;
  printf("is_visible: %d\n", is_visible); // is_visible: 0

  is_visible = 1;  // 结果 false 的变量,只要改为非 0 值,都会变成 1,无论改为正数还是负数
  printf("revised is_visible: %d\n", is_visible); // revised is_visible: 1

  is_visible = 20;
  printf("revised is_visible: %d\n", is_visible); // revised is_visible: 1
}

if 语句

void TestIfElse() {

#define MAGIC_NUMBER 10

  // if else 的例子
  // 猜数字的小例子来一个, 只不过数字固定, 输入次数固定
  int user_input;
  printf("请输入要猜的数字:");
  scanf("%d", &user_input);

  if (user_input < MAGIC_NUMBER) {
    printf("数字小了!\n");
  } else if (user_input > MAGIC_NUMBER) {
    printf("数字大了!\n");
  } else {
    printf("猜对了!\n");
  }

  // 三目运算符的使用 <expr> ? <expr1> : <expr2>
  int a = (user_input < MAGIC_NUMBER) ? -5 : 5;
  printf("a: %d\n", a);
}

switch 语句

void TestSwitchCase() {

#define ADD '+'
#define SUB '-'
#define MULTIPLY '*'
#define DIVIDE '/'
#define REM '%'

  int left;
  char operator;
  int right;
  int result; // 计算结果

  printf("请输入一个表达式:");
  scanf("%d %c %d", &left, &operator, &right);

  switch (operator) {
    case ADD: result = left + right;
      break;
    case SUB: result = left - right;
      break;
    case MULTIPLY: result = left * right;
      break;
    case DIVIDE: result = left / right;
      break;
    case REM: result = left % right;
      break;
    default: printf("输入的符号违法!");
  }
  printf("%d %c %d = %d\n", left, operator, right, result);
}

循环语句

while 循环

#include <stdio.h>

void TestWhile(){
  int sum = 0;
  int num = 1;

  while(num <= 100){
    sum = sum + num;
    num++;
  }

  printf("sum: %d", sum);
}

do while 循环

当使用 do-while 循环进行用户输入时,一个常见的问题是输入后按下的 Enter 键会在输入缓冲区留下一个换行符。这个换行符在下一次输入时可能会干扰程序的正常运行。为了避免这种情况,可以在使用 scanf 函数读取用户输入后,紧接着调用 getchar() 函数来读取并丢弃这个换行符。通过打印 getchar() 的返回值,可以确认其值为 10,这对应于 ASCII 码表中的换行符(’\n’)。

void TestDoWhile() {
#define ADD '+'
#define SUB '-'
#define MULTIPLY '*'
#define DIVIDE '/'
#define REM '%'

  int left;
  char operator;
  int right;
  int result; // 计算结果

  char again; // 是否退出

  do {
    printf("请输入一个表达式:");
    scanf("%d %c %d", &left, &operator, &right);
    getchar();

    switch (operator) {
      case ADD: result = left + right;
        break;
      case SUB: result = left - right;
        break;
      case MULTIPLY: result = left * right;
        break;
      case DIVIDE: result = left / right;
        break;
      case REM: result = left % right;
        break;
      default: printf("输入的符号违法!");
    }

    printf("%d %c %d = %d\n", left, operator, right, result);

    printf("是否继续?");
    scanf("%c", &again);

  } while (again == 'y');
}

for 循环

在C语言的早期版本中,for循环的初始化部分不能包含变量的定义。例如,使用for(int i=0; i<5; i++)这样的语法在 C99 标准之前是不被允许的。然而,随着C99标准的发布,这种在循环条件中定义变量的语法变得合法。

void TestFor(){

  int sum = 0;

  // C99 之后,可以在 for 条件处定义变量
  for(int i=0,j=0; i<=10,j<=10; i++,j++){
    sum = sum + i + j;
  }

  printf("sum: %d", sum);
}

goto 语句

不建议使用

#include <stdio.h>

int main() {

  int i = 0;
begin:
  printf("%d\n", i); // 0 1 2 3 4 5
  if (i++ < 5) { // 比较的时候使用 i,比较完毕 i 就自加
    goto begin;
  }
  return 0;
}
暂无评论

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
下一篇