版權聲明：本文爲博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/hsgwpj/article/details/49431913
</pre><pre name="code" class="cpp"> > File Name: main.c
> Author: khalil
> Mail: [email protected]
> Created Time: Sat 24 Oct 2015 8:56:56 AM CST
************************************************************************/
//查找： GCC加什麼參數可以優化編譯方式
//表查找
//看《程序員的自我修養》
//貝葉斯算法
#if 0
#include<stdio.h>
int main (int argc , char ** argv)
{
//輸入任意字符串,統計\n\t空格的數量
char str1[128] = {0};
char *p = str1;
int i = 0 ;
int j = 0 ;
char ch = '\0';
int n_count = 0;
int t_count = 0;
int s_count = 0;
printf("請輸入字符串,按<C-d>退出：\n");
for ( i = 0 ; i < 128 && ch != EOF ; ++i )
{
ch = getchar();
str1[i] = ch;
switch (ch)
{
case '\n': n_count++;
break;
case '\t': t_count++;
break;
case ' ' : s_count++;
break;
default : break;
}
}
str1[i-1] = '\0';
printf("\n你輸入的字符串爲：\n%s\n",p);
printf("你輸入的\\n,\\t,空格分別爲：%d %d %d \n",n_count,t_count,s_count);
return 0 ;
}
#endif
#if 0
//Unicode 有65535種編碼（2^16）
#define LENGTH (256)
#define ZERO (0)
#include<stdio.h>
int main ( int argc , char ** argv )
{
//空間換取時間：
//
// 時間的寶貴程度一般是大於空間的
//
// 256種字符,
//
// int ASCII_count[256] = {0};
//
// //記錄各個字符出現的次數
// a 97 ASCII_count[97]++ ; // 0 --> 1
// A 65
// 0 48
// \n 10
int i = 0 ;
int ASCII_count[LENGTH] = {0};
char ch = 0;
printf("請輸入任意字符,<C-d>結束:\n")
while ((ch = getchar()) != EOF)
{
ASCII_count[ch]++;
}
for ( i = 0 ; i < LENGTH ; ++i )
{
if( ASCII_count[i] != ZERO )
{
printf("\n字符 %c 出現了\t%d\t次\n",i,ASCII_count[i]);
}
}
return 0;
}
#endif
#if 0
//素數的處理可以採用篩法
#endif
#if 0
/*
* 介紹C語言中的關鍵字
*
*
*/
#include<stdio.h>
#include<time.h>
void func1(void);
void func1(void)
{
auto int a = 10; //等價於 int a = 10;
}
//register int global_value = 0;
//static register int static_value = 0;
void func2(register int i);
void func2(register int i)
{
printf("i = %d\n",i);
}
int main ( int argc , char ** argv )
{
//auto 自動變量
//《程序員的自我修養(編譯、鏈接和庫)》
int a = 10 ; //由函數內部定義的變量,該變量存在於棧上,
//生存週期爲函數調用時定義,函數調用結束時被釋放
func1();
register int i = 0 ; //計數器
// int i = 0; //存在寄存器中的變量會比自動變量快一個數量級
//
//儘量把變量存在寄存器中提升運行速度 但是有空間限制
//
//register 有修飾限制：
//
//1.自動變量 可以
//2.靜態變量 不可以
//3.全局變量 不可以
//4.函數參數 可以
//
//寄存器變量不能直接取址
int *p = &i;
*&i = 233;
printf("%x\n",i);
printf("%x\n",p);
clock_t start = 0; //long long int 類型
clock_t end = 0; //使用clock()進行CPU記時來比較寄存器變量和自動變量的
//區別
start = clock();
for ( i = 0 ; i < 1000000000 ; ++i )
{
//do something;
}
end = clock();
printf ("%lf\n", (double)(end - start)/CLOCKS_PER_SEC) ;
func2(i);
return 0 ;
}
#endif
#if 0
#include<stdio.h>
void func1(void);
void func2(void);
void func1(void)
{
int a = 0;
a++;
printf("a = %d\n",a);
}
void func2(void)
{
static int b = 0;
b++;
printf("b = %d\n",b);
}
///////////////////////////////////////////////////////////////////
void func3(void);
static void func4(void);
void func3(void)
{
;
}
static void func4(void)
{
;
}
int main ( int argc ,char **argv )
{
//static 靜態
//
//1.可以修飾變量：
// （1）靜態全局變量：
// static 全局變量和普通的全局變量有什麼區別？
// （1）二者都先於主函數創建;
// （2）生命週期貫穿整個程序;
// （3）都存在於內存的靜態區;
// （4）區別： 全局變量可以被外部.c文件識別使用,而靜態局部變量
// 只能被本文件使用（而且是從它定義的位置向下開始）;
//
// ---疑問： 鏈接到底做了什麼？ key_word：符號表;
//
// （2）靜態局部變量：
// 在函數內定義
int i = 0;
for ( i = 0 ; i < 10 ; ++i )
{
func1();
func2();
}
//2.static可以修飾函數：
// （1）沒加static的函數：可以被其他.c文件識別
// （2）static函數：只能在本文件使用
//
return 0 ;
}
#endif
#if 0
//編程實現： int ftoi(float value);
//eg:
// int result = ftoi(12.5) //result = 12 float轉換爲int類型
#include<stdio.h>
//浮點數的位存儲形式：
//
// 12.25 => 1100.01(二進制) = 1.10001 * 2^3 (二進制科學技術法)
// 2*3+ 2*2 + 2^-2
//
// 3 -> 指數位
// 10001 -> 尾數
// 0 -> 符號位
//
//規則如下：
// 12.25：
// 0 0000001 |1
// 1111111 |1
// 0 1000001 |0 10001 00 |00000000 |00000000
// f zzzzzzz |z wwwww ---|----補零-|--------
// f符號位 z指數位 w尾數位
// （1）左1位符號位,正數0,負數1
// （2）指數位佔8位 如果是正數 需要加127
// （3）尾數位32-1-8=23位
int ftoi(float value)
{
;
}
int main ( int argc , char **argv )
{
float a = 12.25;
printf("ftoi的結果是：%d\n",ftoi(a));
return 0 ;
}
#endif
#if 0
#include<stdio.h>
#include<string.h>
int main (int argc , char ** argv)
{
int a = 10;
printf("the size of :%d\n",sizeof (int) );
printf("the size of :%d\n",sizeof (a) );
// printf("the size of :%d\n",sizeof int ); //錯誤的
printf("the size of :%d\n",sizeof a );
//sizeof 得到unsigned int 它是關鍵字 不是函數
char str1[] = "hello,world";
char *str2 = "hello,world";
printf("strlen : %d \n",strlen(str1)); // 1. 11
printf("sizeof : %d \n",sizeof(str1)); // 2. 12
//sizeof要多計算'\0'這一位！
printf("strlen : %d \n",strlen(str2)); // 3. 11
printf("sizeof : %d \n",sizeof(str2)); // 4. 8
return 0;
}
#endif
#if 0
//實現strlen
#include<stdio.h>
size_t strlen(const char *p)
{
register int i = 0;
for ( ; *p++ != '\0' ; ++i )
;
return i;
}
int main ( int argc , char ** argv )
{
char * str = "hello,world!";
printf("%d\n",strlen(str));
return 0;
}
#endif
#if 0
#include<stdio.h>
float sum_float_elements(float *arr,unsigned int length)
{
int i = 0;
float result = 0.0;
for(i = 0; i <= length - 1; ++i){
result += arr[i];
}
return result;
}
int main (int argc , char ** argv)
{
//類型提升問題：一般來講,signed類型遇到unsigned類型
// 會提升爲unsigned類型
//
//
float array[] = {12.4,2.5,0.6,23.23,12.44,50.6};
float result = sum_float_elements(array,6);
// float result = sum_float_elements(array,0);
// 如果把最後的參數改爲0
// unsigned類型的第二個參數會變爲0-1後的unsigned int 的最大值
// 導致數組越界
// *建議：儘量使用有符號的類型
printf("result = %f\n",result);
return 0 ;
}
#endif
#if 0
#include<stdio.h>
int main ( int argc , char **argv )
{
; //空語句
8 + 3 ; //表達式
int a = 10;
float c = 5.6;
float f = 5.6;
double d = 7.5;
int *p = &a;
//順序執行的語句
//1.
//
//分支語句
//
if(/*表達式*/1){
//do sth.
}else{
//do sth.
}
//推薦使用的形式
//
//switch () 的優化 <- GCC 加什麼參數可以以表查詢
//
//switch cases中的值不連續的時候 編譯器會生成一個二叉樹進行查找
//
//
return 0;
}
#endif
#if 0
#include<stdio.h>
#include<stdlib.h>
#define TRUE (1)
#define FALSE (0)
typedef unsigned char Boolean;
Boolean func1(void);
Boolean func2(void);
Boolean func3(void);
Boolean func1(void)
{
return FALSE;
}
Boolean func2(void)
{
return FALSE;
}
Boolean func3(void)
{
return FALSE;
}
int main (int argc , char **argv )
{
Boolean ok = TRUE;
int *p_int = NULL;
//申請內存資源
p_int = (int *) malloc (sizeof(int) * 10);
if (p_int == NULL){
printf("The memory is full!\n");
exit(1);
}
#if 1 //連續檢測調用函數的返回值 ver.final
//&&的短路運算
if (func1() == TRUE
&& func2() == TRUE
&& func3() == TRUE){
;
}
free(p_int);
#endif
#if 0 //連續檢測調用函數的返回值 ver.2
do{
if ((ok = func1()) == FALSE){
break;
}
if ((ok = func2()) == FALSE){
break;
}
if ((ok = func3()) == FALSE){
break;
}
}while(0);
free(p_int);
#endif
#if 0 //連續檢測調用函數的返回值 ver.1
//分別調用函數
ok = func1();
if (ok == FALSE){
free(p_int);
exit(12);
}
ok = func2();
if (ok == FALSE){
free(p_int);
exit(1);
}
ok = func3();
if (ok == FALSE){
free(p_int);
exit(1);
}
free(p_int);
#endif
return 0 ;
}
#endif
#if 0
#include<stdio.h>
//break continue語句
int main ( int argc , char ** argv )
{
int array [100] = {0};
int i = 0;
int j = 0;
for ( i = 0 ; i <100 ; ++i ){
for ( j = 0 ; ; < 100 ; ++j ){
if ( i > 50 ){
break ; //break跳出最近的一層循環語句
}
}
}
//或者配合switch case---
for ( i = 0 ; i <100 ; ++i ){
for ( j = 0 ; ; < 100 ; ++j ){
if ( i > 50 ){
continue ; //continue跳出本次循環,進入下一次循環
}
printf("I do not continued!\n");
}
}
}
#endif
#if 0
// goto
#include<stdio.h>
#include<stdlib.h>
#define TRUE (1)
#define FALSE (0)
typedef unsigned char Boolean;
Boolean func1(void);
Boolean func2(void);
Boolean func3(void);
Boolean func1(void)
{
return FALSE;
}
Boolean func2(void)
{
return FALSE;
}
Boolean func3(void)
{
return FALSE;
}
int main (int argc , char **argv )
{
Boolean ok = TRUE;
int *p_int = NULL;
//申請內存資源
p_int = (int *) malloc (sizeof(int) * 10);
if (p_int == NULL){
printf("The memory is full!\n");
exit(1);
}
if ((ok = func1()) == FALSE){
goto FAILED_FUNC;
}
if ((ok = func1()) == FALSE){
goto FAILED_FUNC;
}
if ((ok = func1()) == FALSE){
goto FAILED_FUNC;
}
free(p_int);
return 0 ;
FAILED_FUNC:
free(p_int);
exit(1);
}
#endif
#if 0
#include<stdio.h>
//無返回類型的函數默認返回爲int？
sum (int a ,int b);
sum (int a ,int b)
{
return a + b;
}
int main ( int argc, char **argv )
{
// void a ; //X -> 編譯器無法獲得分配內存的大小
void * p ; //V -> 指針在32位下4字節 64位下8自己
//它可以接受任意類型指針,是泛型編程的基礎！
//
int result = 0 ;
result = sum (10 , 20);
printf("result = %d\n",result);
return 0 ;
//return 在void類型中可以作爲break使用*
}
#endif
#if 0
#include<stdio.h>
int main (int argc , char **argv)
{
volatile int i = 10;
//忽略編輯器的優化，每次對變量的訪問都從變量的地址讀取
//安全， 防止多線程操作時的誤操作
int j = i ;
int k = i ;
return 0 ;
}
#endif
#if 0
#include<stdio.h>
typedef struct List_node{
int data;
struct List_node *next;
}List_node;
typedef void(*Swap)(void *a , void *b);
//typedef void(*)(void *a , void *b) Swap; //<= 編譯器會報錯
// 一個意思-> 函數指針，Swap類型的變量可以指向形如
// void func(void *a, void *b)的函數
void func1(void *a , void *b);
void func1(void *a , void *b)
{
;
}
int main ( int argc ,char ** argv )
{
Swap swap = func1;
struct List_node a;
List_node b;
//一個意思
//
return 0;
}
#endif