C語言練習代碼
概述
常規操做
1. 數據表達
1.1 量
1.1.1 常量
1.1.2 變量
1.2 數據類型
1.2.1 基本數據類型
1.2.2 擴展數據類型
2. 控制結構
2.1 條件控制
2.2 循環控制
指針操做
常規操做
1. 數據表達
1.1 量
1.1.1 常量
1.1.2 變量
1.2 數據類型
1.2.1 基本數據類型
1.2.2 擴展數據類型
2. 控制結構
2.1 條件控制
2.2 循環控制
指針操做
概述
本篇博客(筆記）主要是根據本身對編程語言和C編程語言的理解，總結複習所創做的，包括簡單的概述和主要的實現代碼。
不一樣於另一篇博客《關於編程.md》中介紹的內容 ，本篇博客主要是代碼乾貨。html
常規操做
1. 數據表達
數據表達主要包括：量的概念，數據類型，數據運算，表達式 ，返回值，共5部份內容（目前暫且總結如此）。編程
1.1 量
1.1.1 常量
常量是直接指定的字面量。
示例代碼段：數組
/*
*本段程序代理主要在於:量-常量的學習和使用
*/
#include<stdio.h>
int main(){
printf("I am number:100\n"); //經過printf函數，打印字符串常量，整型常量，轉義字符(字符常量)
return 0;
}
1.1.2 變量
變量是某塊約定大小（約定大小能夠理解爲數據類型）的內存區域的標籤。
變量=內存區域，變量值=內存存放值，變量地址=內存地址，變量聲明=編譯器開闢內存
取值操做=取內存地址，解引地址=取內存值
示例代碼段：數據結構
/*
*本段程序代理主要在於:量-變量的學習和使用
*/
#include<stdio.h>
int main(){
//整型變量
int int_var_001 = 100;
printf("int_var_001 is :%d\n",int_var_001);
//字符變量
char char_var_001 = 'A';
printf("char_var_001 is :%c\n",char_var_001);
//字符串變量
char * string_var_001 = "liwanliang";
printf("string_var_001:%s\n",string_var_001);
return 0;
}
1.2 數據類型
編程語言的數據類型均可以分爲兩大類：基本數據類型，擴展數據類型（或者構造數據類型）
同時任何數據都只有兩種表現方式：數，字符，這是數據的基本組成元素。基本元素組成基本數據類型。
C語言基本數據類型包括：整型，字符，字符串，枚舉，空類型編程語言
1.2.1 基本數據類型
/*
* 本程序段主要打印內置的數據類型，取值範圍，最值等
*/
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main(){
printf("----------size------------\n");
printf("1 byte,sizeof(char):%d\n",sizeof(char));
printf("2 byte,sizeofof(short int):%d\n",sizeof(short));
printf("4 byte,sizeofof(int):%d\n",sizeof(int));
printf("4 byte,sizeofof(float):%d\n",sizeof(float));
printf("8 byte,sizeofof(long int):%d\n",sizeof(long));
printf("8 byte,sizeofof(double):%d\n",sizeof(double));
printf("--------max and min------\n");
printf("char max:%d,char min:%d\n",CHAR_MAX,CHAR_MIN);
printf("unsign char max:%d,char min:%d\n",UCHAR_MAX,0);
printf("short max:%d,short min:%d\n",SHRT_MAX,SHRT_MIN);
printf("unsign short max:%d,short min:%d\n",USHRT_MAX,0);
printf("int max:%d,int min:%d\n",INT_MAX,INT_MIN);
printf("unsign int max:%ld,int min:%ld\n",UINT_MAX,0);
printf("long max:%ld,long min:%ld\n",LONG_MAX,LONG_MIN);
printf("unsign long max:%lld,long min:%ld\n",ULONG_MAX,0);
printf("FLT_MAX:%f,FLT_MIN:%f\n",FLT_MAX,FLT_MIN);
printf("DBL_MAX:%f\n,DBL_MIN:%f\n",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\n",i,i);
}
//循環輸出數組值
for ( int i = 0; i < SIZE; i++ )
{
printf("int_array_002[%d] + 100 = %d\n",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("\n");
//字符數組初始化
char char_array_002[SIZE];
for ( int i = 0; i < SIZE; i++ )
{
char_array_002[i] = 'A';
printf("char_array_002[%d]:%c\n",i,char_array_002[i]);
}
//字符串
char *name = "liwanliang";
//printf("%s\n",name);
char char_array_003[sizeof("liwanliang")];
//printf("%d\n",sizeof("liwanliang"));
for ( int i = 0; i < sizeof("liwanliang"); i++ )
{
printf("%c ",*name++);
}
printf("\n");
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\n",j,i,int_array_001[i][j]);
}
}
//int型二位數組
printf("\n");
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",n,m,int_array_002[n][m]);
}
}
//char型二維數組，未賦初值
printf("\n");
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\n",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\n",str_liwl_001.id);
printf("str_liwl_001.name:%s\n",str_liwl_001.name);
printf("str_liwl_001.age:%d\n",str_liwl_001.age);
printf("str_liwl_001.sex:%c\n",str_liwl_001.sex);
printf("\n");
//結構體數組.其初始化能夠在聲明時進行，也能夠單獨進行(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\n",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\n",struct_liwl_002.int_array_001[2]);
printf("%d,%s,%c\n",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\n");
if ( 0 ) //表達式結果零，不執行
printf("This line can't be print\n");
if ( 1 )
printf("1\n"); //非零值執行
//若是，那麼 | 單條件，單分支
int int_var_001 = 100;
//if ( 1 )
if ( int_var_001 > 1 )
printf("int_var_001:%d > 1\n",int_var_001);
printf("\n");
//若是就，不然就 | 單條件，雙分支
if ( int_var_001 > 101 )
printf("int_var_001:%d > 101\n",int_var_001);
else
printf("int_var_001:%d < 101\n",int_var_001);
printf("\n");
//若是,就;不然若是,就;不然若是,就;不然,就 | 單條件，多分支
if ( int_var_001 > 50 )
printf("int_var_001:%d >= 100\n",int_var_001);
else if ( 50 < int_var_001 < 100 )
printf("50 < int_var_001:%d < 100\n",int_var_001);
else if ( int_var_001 >= 100 )
printf("int_var_001:%d >= 100\n",int_var_001);
else
printf("int_var_001:%d < 50\n",int_var_001);
//若是:若是,就:就 | 嵌套
if ( int_var_001 > 50 )
{
printf("int_var_001:%d > 50\n",int_var_001);
if ( int_var_001 > 80 )
//{
printf("int_var_001:%d > 80\n",int_var_001);
//}
}
else
//{
printf("int_var_001:%d < 50\n",int_var_001);
//}
printf("\n");
/*多個條件的狀況*/
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\n",int_var_003,int_var_002);
printf("int_var_003:%d - int_var_002:%d = %d\n",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\n",int_var_003,int_var_002,int_var_001);
else
printf("判斷失敗\n");
//嵌套 | 多個條件，多分支
if ( int_var_003 < int_var_002 && int_var_001 == 100 )
printf("首個條件判斷成立\n");
else if ( int_var_003 == 300 && int_var_002 == 200 && int_var_001 == 100 )
printf("第二個條件判斷成立\n");
else
printf("判斷失敗\n");
// 三元表達式：等價於雙分支
printf("%d\n",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\n");
break;
case 10:
printf("10\n");
break;
case 100:
printf("100\n");
break;
default: //無匹配值時的默認值
printf("no\n");
}
// 條件跳轉和返回
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\n",int_var_004);
}
printf("Last line\n");
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\n",int_var_001);
printf("int_var_001:%d,是%c\n",int_var_001,int_var_001%2?'A':'B');
}
printf("\n");
/*while*/ //先遍歷條件判斷,後操做
int int_var_002 = 10 ;
while ( int_var_002 != 0 )
{
printf("int_var_002:%d\n",int_var_002);
int_var_002--;
}
printf("\n");
/*do-while*/ //先操做,後遍歷條件判斷
int int_var_003 = 10;
do {
printf("int_var_003:%d\n",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\n",*p_int_a); //*表示解引指針=獲取內存值
//////字符變量指針
char char_a = 'A';
char *p_char_a = &char_a;
printf("%c\n",*p_char_a);
//////字符串變量指針
char *string_a = "liwanliang";
char **p_string_a = &string_a;
printf("%s\n",*p_string_a);
printf("\n");
////數組指針
//////整型數組指針
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\n",*(p_array_001+2));
int i001 = 0;
for ( i001 = 0; i001 < 4; i001++ ) //for循環體中只有一行語句時，括號可省略
//{
printf("array_001[%d]:%d\n",i001,*p_array_001++); //*p_array_001++，指針運算，取值後指針+1xsize
// printf("array_001[%d]:%d\n",i001,array_001[i001]); //等效於上一行
//}
printf("\n");
//////字符數組指針,同上
//////字符串數組指針
char *array_002[3] = {"lwl","liwl","liwanliang"};
char **p_array_002 = array_002;
int i002 = 0;
for ( i002 = 0; i002 < 3; i002++ )
//{
printf("%s\n",*p_array_002++);
// printf("%s\n",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\n",array_005,&array_005[0],&array_005[0][0],*array_005); //二維數組首地址的四種表示方式
int (*p_array_005)[4] = array_005; //定義一個數組指針(基本數據類型指針，擴展數據類型指針),這裏是擴展數據類型指針-數組指針
printf("%d\n",*(*(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("---------\n");
//////字符串二維數組
////結構體指針
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\n",p_str_liwl_001->id,p_str_liwl_001->sex,p_str_liwl_001->name); //不須要解引符號的取值操做
printf("\n");
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\n",p_str_liwl_002->array_int_002[3],p_str_liwl_002->array_char_002[3]); //數組仍是以普通方式索引
printf("\n");
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\n",p_str_liwl_003->p_array_int[i003],p_str_liwl_003->p_array_char[i003]);
printf("\n");
for ( i003 = 0; i003 < 4; i003++ )
printf("%d,%c\n",*(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/6486327ui
相關文章
- 1. Ubuntu下的C語言代碼練習
- 2. C語言代碼訓練1
- 3. C語言 練手代碼（4）
- 4. C語言編程練習——ISBN碼
- 5. C語言：指針練習
- 6. C語言練習題
- 7. c語言小練習6
- 8. week3 C語言練習
- 9. c語言練習題（一）
- 10. C語言數組練習
- 更多相關文章...
- • ASP.NET Razor - C# 和 VB 代碼語法 - ASP.NET 教程
- • C# 不安全代碼 - C#教程
- • Kotlin學習（一）基本語法
- • IntelliJ IDEA代碼格式化設置
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Ubuntu下的C語言代碼練習
- 2. C語言代碼訓練1
- 3. C語言 練手代碼（4）
- 4. C語言編程練習——ISBN碼
- 5. C語言：指針練習
- 6. C語言練習題
- 7. c語言小練習6
- 8. week3 C語言練習
- 9. c語言練習題（一）
- 10. C語言數組練習