概述
本篇博客(笔记）主要是根据自己对编程语言和C编程语言的理解，总结复习所创作的，包括简单的概述和主要的实现代码。
不同于另外一篇博客《关于编程.md》中介绍的内容 ，本篇博客主要是代码干货。
常规操作
1. 数据表达
数据表达主要包括：量的概念，数据类型，数据运算，表达式 ，返回值，共5部分内容（目前暂且总结如此）。
1.1 量
1.1.1 常量
常量是直接指定的字面量。
示例代码段：
/*
*本段程序代理主要在于:量-常量的学习和使用
*/
#include<stdio.h>
int main(){
printf("I am number:100
"); //通过printf函数，打印字符串常量，整型常量，转义字符(字符常量)
return 0;
}1.1.2 变量
变量是某块约定大小（约定大小可以理解为数据类型）的内存区域的标签。
变量=内存区域，变量值=内存存放值，变量地址=内存地址，变量声明=编译器开辟内存
取值操作=取内存地址，解引地址=取内存值
示例代码段：
/*
*本段程序代理主要在于:量-变量的学习和使用
*/
#include<stdio.h>
int main(){
//整型变量
int int_var_001 = 100;
printf("int_var_001 is :%d
",int_var_001);
//字符变量
char char_var_001 = 'A';
printf("char_var_001 is :%c
",char_var_001);
//字符串变量
char * string_var_001 = "liwanliang";
printf("string_var_001:%s
",string_var_001);
return 0;
}1.2 数据类型
编程语言的数据类型都可以分为两大类：基本数据类型，扩展数据类型（或者构造数据类型）
同时任何数据都只有两种表现方式：数，字符，这是数据的基本组成元素。基本元素组成基本数据类型。
C语言基本数据类型包括：整型，字符，字符串，枚举，空类型
1.2.1 基本数据类型
/*
* 本程序段主要打印内置的数据类型，取值范围，最值等
*/
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main(){
printf("----------size------------
");
printf("1 byte,sizeof(char):%d
",sizeof(char));
printf("2 byte,sizeofof(short int):%d
",sizeof(short));
printf("4 byte,sizeofof(int):%d
",sizeof(int));
printf("4 byte,sizeofof(float):%d
",sizeof(float));
printf("8 byte,sizeofof(long int):%d
",sizeof(long));
printf("8 byte,sizeofof(double):%d
",sizeof(double));
printf("--------max and min------
");
printf("char max:%d,char min:%d
",CHAR_MAX,CHAR_MIN);
printf("unsign char max:%d,char min:%d
",UCHAR_MAX,0);
printf("short max:%d,short min:%d
",SHRT_MAX,SHRT_MIN);
printf("unsign short max:%d,short min:%d
",USHRT_MAX,0);
printf("int max:%d,int min:%d
",INT_MAX,INT_MIN);
printf("unsign int max:%ld,int min:%ld
",UINT_MAX,0);
printf("long max:%ld,long min:%ld
",LONG_MAX,LONG_MIN);
printf("unsign long max:%lld,long min:%ld
",ULONG_MAX,0);
printf("FLT_MAX:%f,FLT_MIN:%f
",FLT_MAX,FLT_MIN);
printf("DBL_MAX:%f
,DBL_MIN:%f
",DBL_MAX,DBL_MIN);
return 0;
}1.2.2 扩展数据类型
/*
* 扩展数据类型:数组
* 整型数组的定义，初始化，值运算
* 字符数组和字符串
*/
#include<stdio.h>
#define SIZE 4
int main(){
//未初始化整型数组
int int_array_001[SIZE];
//初始化整型数组
int int_array_002[SIZE] = {1,2,3,4};
//循环进行数组初始化
for ( int i = 0; i < SIZE; i++ )
{
int_array_001[i] = i;
printf("int_array_001[%d] is : %d
",i,i);
}
//循环输出数组值
for ( int i = 0; i < SIZE; i++ )
{
printf("int_array_002[%d] + 100 = %d
",i,i+100);
}
//字符数组
char char_array_001[SIZE] = {'l','i','w','l'};
for ( int i = 0; i < SIZE; i++ )
{
printf("%c",char_array_001[i]);
}
printf("
");
//字符数组初始化
char char_array_002[SIZE];
for ( int i = 0; i < SIZE; i++ )
{
char_array_002[i] = 'A';
printf("char_array_002[%d]:%c
",i,char_array_002[i]);
}
//字符串
char *name = "liwanliang";
//printf("%s
",name);
char char_array_003[sizeof("liwanliang")];
//printf("%d
",sizeof("liwanliang"));
for ( int i = 0; i < sizeof("liwanliang"); i++ )
{
printf("%c ",*name++);
}
printf("
");
return 0;
}扩展数据类型-数组
/*
* 本代码段主要学习二位数组
* 主要是整型，字符，字符串型二维数组
*/
#include<stdio.h>
#define SIZE_C 2
#define SIZE_K 2
int main(){
//int型二维数组，未赋初值
int int_array_001[SIZE_C][SIZE_K];
int i,j;
for ( j = 0; j < SIZE_K; j++ )
{
for ( i = 0; i < SIZE_C; i++ )
{
int_array_001[i][j]=i+j;
printf("int_array_001[%d][%d]:%d
",j,i,int_array_001[i][j]);
}
}
//int型二位数组
printf("
");
int int_array_002[SIZE_C][SIZE_K] = {{1,2},{3,4}};
int m,n;
for ( n = 0; n < SIZE_K; n++ )
{
for ( m = 0; m < SIZE_C; m++ )
{
printf("int_array_002[%d][%d]:%d
",n,m,int_array_002[n][m]);
}
}
//char型二维数组，未赋初值
printf("
");
char char_array_001[SIZE_C][SIZE_K];
int k,t;
for ( t = 0; t < SIZE_K; t++ )
{
for ( k = 0; k < SIZE_C; k++ )
{
char_array_001[k][t] = 'A'+k+t;
printf("char_array_001[%d][%d]:%c
",t,k,char_array_001[k][t]);
}
}
return 0;
}扩展数据类型-结构体
/*
* 本段代码主要用于学习结构体的实践
* 结构体是基于基本数据结构扩展的数据类型
* 因为数组也是数据类型，相互结合就会存在结构体数组和数组结构体的概念
* 结构体实际上相当于自己定义了一个静态类型数据类型
*/
#include<stdio.h>
int main(){
/*
* 结构体内部只用于定义数据类型，不能初始化
* 定义数据类型知识告诉编译器其存储结构
*/
struct struct_001{
//ID
unsigned int id;
//字符串型
char *name;
//int型
int age;
//字符型
char sex;
};
struct struct_001 str_liwl_001 = { 9, "liwanliang", 28, 'M' };
//重命名struct_001数据类型
//typedef struct struct_001 str_001;
//声明变量
//str_001 str_liwl_001;
//str_001 str_liwl_001 = { 0,"liwanliang01",28,'M'};
printf("str_liwl_001.id:%d
",str_liwl_001.id);
printf("str_liwl_001.name:%s
",str_liwl_001.name);
printf("str_liwl_001.age:%d
",str_liwl_001.age);
printf("str_liwl_001.sex:%c
",str_liwl_001.sex);
printf("
");
//结构体数组.其初始化可以在声明时进行，也可以单独进行(for循环)。
struct struct_001 struct_array_001[3] = {{0,"liwanliang01",21,'M'},{1,"liwanliang02",22,'F'},{2,"liwanliang03",23,'N'},};
int i = 0;
for ( i = 0; i < 3; i++ )
printf("%d,%s,%d,%c
",struct_array_001[i].id,struct_array_001[i].name,struct_array_001[i].age,struct_array_001[i].sex);
//结构体元素包括数组，结构体
struct struct_002 {
int int_array_001[3];
struct struct_001 struct_liwl_01;
struct struct_001 struct_liwl_02[3];
};
struct struct_002 struct_liwl_002 = { {1,2,3},{0,"liwanliang1",21,'M'}, };
printf("%d
",struct_liwl_002.int_array_001[2]);
printf("%d,%s,%c
",struct_liwl_002.struct_liwl_01.id,struct_liwl_002.struct_liwl_01.name,struct_liwl_002.struct_liwl_01.sex);
return 0;
}2. 控制结构
2.1 条件控制
/*
* 本程序片段主要学习控制结构-条件控制
* 条件控制
* 是对if语句后的(条件)表达式的返回值进行真值判断,根据不同的真值结果执行不同的语句模块
* if 语句的三种模型:
* 1.如果，那么
* 2.如何就，否则就
* 3.嵌套
*/
#include<stdio.h>
int main(){
//if 基本原理:表达式结果为真时执行.大多是条件表达式，很少是量(常量或者变量)，或者运算表达式
if ( ! 0 ) //表达式结果非零,执行语句
printf("This line cat be print,because of !0
");
if ( 0 ) //表达式结果零，不执行
printf("This line can't be print
");
if ( 1 )
printf("1
"); //非零值执行
//如果，那么 | 单条件，单分支
int int_var_001 = 100;
//if ( 1 )
if ( int_var_001 > 1 )
printf("int_var_001:%d > 1
",int_var_001);
printf("
");
//如果就，否则就 | 单条件，双分支
if ( int_var_001 > 101 )
printf("int_var_001:%d > 101
",int_var_001);
else
printf("int_var_001:%d < 101
",int_var_001);
printf("
");
//如果,就;否则如果,就;否则如果,就;否则,就 | 单条件，多分支
if ( int_var_001 > 50 )
printf("int_var_001:%d >= 100
",int_var_001);
else if ( 50 < int_var_001 < 100 )
printf("50 < int_var_001:%d < 100
",int_var_001);
else if ( int_var_001 >= 100 )
printf("int_var_001:%d >= 100
",int_var_001);
else
printf("int_var_001:%d < 50
",int_var_001);
//如果:如果,就:就 | 嵌套
if ( int_var_001 > 50 )
{
printf("int_var_001:%d > 50
",int_var_001);
if ( int_var_001 > 80 )
//{
printf("int_var_001:%d > 80
",int_var_001);
//}
}
else
//{
printf("int_var_001:%d < 50
",int_var_001);
//}
printf("
");
/*多个条件的情况*/
int int_var_002 = 200;
int int_var_003 = 300;
//如果，那么 | 多个条件，单分支
if ( int_var_003 > int_var_002 && int_var_001 > 50 )
{
printf("int_var_003:%d > int_var_002:%d
",int_var_003,int_var_002);
printf("int_var_003:%d - int_var_002:%d = %d
",int_var_003,int_var_002,int_var_003 - int_var_002);
}
//如果就，否则就 | 多个条件，双分支
if ( int_var_003 < int_var_002 || int_var_001 != 100 )
printf("int_var_003:%d < intt_var_002:%d 或者 int_var_001 = %d
",int_var_003,int_var_002,int_var_001);
else
printf("判断失败
");
//嵌套 | 多个条件，多分支
if ( int_var_003 < int_var_002 && int_var_001 == 100 )
printf("首个条件判断成立
");
else if ( int_var_003 == 300 && int_var_002 == 200 && int_var_001 == 100 )
printf("第二个条件判断成立
");
else
printf("判断失败
");
// 三元表达式：等价于双分支
printf("%d
",int_var_003 > int_var_002 ? int_var_003 : int_var_002);
// swtich语句: 等价于多分支
switch (int_var_003 - int_var_002) { //switch后跟表达式:赋值表达式,运算表达式,条件表达式,逻辑表达式等
case 1: //case是表达式的返回值
printf("1
");
break;
case 10:
printf("10
");
break;
case 100:
printf("100
");
break;
default: //无匹配值时的默认值
printf("no
");
}
// 条件跳转和返回
int int_var_004 = 0;
int int_var_005 = 5;
for ( int_var_004 = 0; int_var_004 < 10; int_var_004++ )
{
if ( int_var_004 == int_var_005 )
return; //结束函数，退出(本段代码会直接跳出主函数，不执行Last line
//break; //跳出循环，执行Last line
//continue; //跳过本次循环，执行Last line
printf("run at:%d
",int_var_004);
}
printf("Last line
");
return 0;
}2.2 循环控制
#include<stdio.h>
int main(){
/*for*/ //根据条件遍历一次
int int_var_001 = 0;
for ( int_var_001 = 0; int_var_001 < 10; int_var_001++ )
{
//printf("int_var_001:%d
",int_var_001);
printf("int_var_001:%d,是%c
",int_var_001,int_var_001%2?'A':'B');
}
printf("
");
/*while*/ //先遍历条件判断,后操作
int int_var_002 = 10 ;
while ( int_var_002 != 0 )
{
printf("int_var_002:%d
",int_var_002);
int_var_002--;
}
printf("
");
/*do-while*/ //先操作,后遍历条件判断
int int_var_003 = 10;
do {
printf("int_var_003:%d
",int_var_003);
int_var_003--;
} while ( int_var_003 != 0 );
return 0;
}指针操作
/*
* 本代码段主要学习指针内容
*/
#include<stdio.h>
int main(){
/*
*数据类型指针
*/
//量
////常量指针
////变量指针
//////整型变量指针
int int_a = 100;
int *p_int_a = &int_a; //*表示指针的声明
printf("%d
",*p_int_a); //*表示解引指针=获取内存值
//////字符变量指针
char char_a = 'A';
char *p_char_a = &char_a;
printf("%c
",*p_char_a);
//////字符串变量指针
char *string_a = "liwanliang";
char **p_string_a = &string_a;
printf("%s
",*p_string_a);
printf("
");
////数组指针
//////整型数组指针
int array_001[4] = {1,2,3,4};
int *p_array_001 = array_001; //数组名就是数组首地址,也是第一个元素的地址
/*上行代码等效 int *p_array_001 = &array_001[0] */
printf("array_001[2]:%d
",*(p_array_001+2));
int i001 = 0;
for ( i001 = 0; i001 < 4; i001++ ) //for循环体中只有一行语句时，括号可省略
//{
printf("array_001[%d]:%d
",i001,*p_array_001++); //*p_array_001++，指针运算，取值后指针+1xsize
// printf("array_001[%d]:%d
",i001,array_001[i001]); //等效于上一行
//}
printf("
");
//////字符数组指针,同上
//////字符串数组指针
char *array_002[3] = {"lwl","liwl","liwanliang"};
char **p_array_002 = array_002;
int i002 = 0;
for ( i002 = 0; i002 < 3; i002++ )
//{
printf("%s
",*p_array_002++);
// printf("%s
",array_002[i002]); //等效于上一行
//};
////二维数组指针
//在二维数组中，一维数组可以看成是基本数据类型，关系同字符和字符串
/*二维数组需要定义一个指向扩展类型的指针，而不是指向基本数据类型的指针*/
//////整型二维数组
int array_005 [4][4] = {{1,2,3,4},{5,6,7,8},{11,12,13,14},{15,16,17,18}};
printf("%d,%d,%d,%d
",array_005,&array_005[0],&array_005[0][0],*array_005); //二维数组首地址的四种表示方式
int (*p_array_005)[4] = array_005; //定义一个数组指针(基本数据类型指针，扩展数据类型指针),这里是扩展数据类型指针-数组指针
printf("%d
",*(*(p_array_005+3)+1));
int i004,i005 = 0;
for ( i004 = 0; i004 < 4; i004++ )
{
for ( i005 = 0; i005 < 4; i005++ )
printf("%d ",*(*(p_array_005+i004)+i005));
}
printf("---------
");
//////字符串二维数组
////结构体指针
struct struct_var_001{
int id;
char sex;
char *name;
}; //定义普通结构体
struct struct_var_001 str_liwl_001 = {1,'M',"liwanliang"}; //声明结构体变量
struct struct_var_001 *p_str_liwl_001 = &str_liwl_001;
printf("%d,%c,%s
",p_str_liwl_001->id,p_str_liwl_001->sex,p_str_liwl_001->name); //不需要解引符号的取值操作
printf("
");
struct struct_var_002{
int array_int_002[4];
char array_char_002[4];
}; //带数组元素的结构体
struct struct_var_002 str_liwl_002 = {{1,2,3,4},{'A','B','C','D'}};
struct struct_var_002 *p_str_liwl_002 = &str_liwl_002;
printf("%d,%c
",p_str_liwl_002->array_int_002[3],p_str_liwl_002->array_char_002[3]); //数组还是以普通方式索引
printf("
");
struct struct_var_003{
int array_int_003[4];
int *p_array_int;
char array_char_003[4];
char *p_array_char;
}; //带指针元素的结构体
struct struct_var_003 str_liwl_003 = {{1,2,3,4},NULL,{'A','B','C','D'},NULL};
struct struct_var_003 *p_str_liwl_003 = &str_liwl_003;
p_str_liwl_003->p_array_int = (int *)&(p_str_liwl_003->array_int_003); //将结构体的第一个元素地址赋值给第二个元素,需要强制类型转换
p_str_liwl_003->p_array_char = (char *)&(p_str_liwl_003->array_char_003);
int i003 = 0;
for ( i003 = 0; i003 < 4; i003++ )
printf("%d,%c
",p_str_liwl_003->p_array_int[i003],p_str_liwl_003->p_array_char[i003]);
printf("
");
for ( i003 = 0; i003 < 4; i003++ )
printf("%d,%c
",*(p_str_liwl_003->p_array_int)+i003,*(p_str_liwl_003->p_array_char)+i003);
////函数指针
////指针的指针
return 0;
}
/*
* 本代码段主要学习指针内容
*/
#include<stdio.h>
int main(){
/*
*数据类型指针
*/
//量
////常量指针
////变量指针
//////整型变量指针
int int_a = 100;
int *p_int_a = &int_a; //*表示指针的声明
printf("%d
",*p_int_a); //*表示解引指针=获取内存值
//////字符变量指针
char char_a = 'A';
char *p_char_a = &char_a;
printf("%c
",*p_char_a);
//////字符串变量指针
char *string_a = "liwanliang";
char **p_string_a = &string_a;
printf("%s
",*p_string_a);
printf("
");
////数组指针
//////整型数组指针
int array_001[4] = {1,2,3,4};
int *p_array_001 = array_001; //数组名就是数组首地址,也是第一个元素的地址
/*上行代码等效 int *p_array_001 = &array_001[0] */
printf("array_001[2]:%d
",*(p_array_001+2));
int i001 = 0;
for ( i001 = 0; i001 < 4; i001++ ) //for循环体中只有一行语句时，括号可省略
//{
printf("array_001[%d]:%d
",i001,*p_array_001++); //*p_array_001++，指针运算，取值后指针+1xsize
// printf("array_001[%d]:%d
",i001,array_001[i001]); //等效于上一行
//}
printf("
");
//////字符数组指针,同上
//////字符串数组指针
char *array_002[3] = {"lwl","liwl","liwanliang"};
char **p_array_002 = array_002;
int i002 = 0;
for ( i002 = 0; i002 < 3; i002++ )
//{
printf("%s
",*p_array_002++);
// printf("%s
",array_002[i002]); //等效于上一行
//};
////二维数组指针
//在二维数组中，一维数组可以看成是基本数据类型，关系同字符和字符串
/*二维数组需要定义一个指向扩展类型的指针，而不是指向基本数据类型的指针*/
//////整型二维数组
int array_005 [4][4] = {{1,2,3,4},{5,6,7,8},{11,12,13,14},{15,16,17,18}};
printf("%d,%d,%d,%d
",array_005,&array_005[0],&array_005[0][0],*array_005); //二维数组首地址的四种表示方式
int (*p_array_005)[4] = array_005; //定义一个数组指针(基本数据类型指针，扩展数据类型指针),这里是扩展数据类型指针-数组指针
printf("%d
",*(*(p_array_005+3)+1));
int i004,i005 = 0;
for ( i004 = 0; i004 < 4; i004++ )
{
for ( i005 = 0; i005 < 4; i005++ )
printf("%d ",*(*(p_array_005+i004)+i005));
}
printf("---------
");
//////字符串二维数组
////结构体指针
struct struct_var_001{
int id;
char sex;
char *name;
}; //定义普通结构体
struct struct_var_001 str_liwl_001 = {1,'M',"liwanliang"}; //声明结构体变量
struct struct_var_001 *p_str_liwl_001 = &str_liwl_001;
printf("%d,%c,%s
",p_str_liwl_001->id,p_str_liwl_001->sex,p_str_liwl_001->name); //不需要解引符号的取值操作
printf("
");
struct struct_var_002{
int array_int_002[4];
char array_char_002[4];
}; //带数组元素的结构体
struct struct_var_002 str_liwl_002 = {{1,2,3,4},{'A','B','C','D'}};
struct struct_var_002 *p_str_liwl_002 = &str_liwl_002;
printf("%d,%c
",p_str_liwl_002->array_int_002[3],p_str_liwl_002->array_char_002[3]); //数组还是以普通方式索引
printf("
");
struct struct_var_003{
int array_int_003[4];
int *p_array_int;
char array_char_003[4];
char *p_array_char;
}; //带指针元素的结构体
struct struct_var_003 str_liwl_003 = {{1,2,3,4},NULL,{'A','B','C','D'},NULL};
struct struct_var_003 *p_str_liwl_003 = &str_liwl_003;
p_str_liwl_003->p_array_int = (int *)&(p_str_liwl_003->array_int_003); //将结构体的第一个元素地址赋值给第二个元素,需要强制类型转换
p_str_liwl_003->p_array_char = (char *)&(p_str_liwl_003->array_char_003);
int i003 = 0;
for ( i003 = 0; i003 < 4; i003++ )
printf("%d,%c
",p_str_liwl_003->p_array_int[i003],p_str_liwl_003->p_array_char[i003]);
printf("
");
for ( i003 = 0; i003 < 4; i003++ )
printf("%d,%c
",*(p_str_liwl_003->p_array_int)+i003,*(p_str_liwl_003->p_array_char)+i003);
////函数指针
////指针的指针
return 0;
}参考教程：
http://c.biancheng.net/cpp/html/2930.html
https://blog.csdn.net/jhcconan614/article/category/6486327