</pre><pre name="code" class="cpp"> > File Name: main.c
> Author: khalil
> Mail: hsgwpj@gmail.com
> 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
【2015/10/24】C学习日志_Day 9 关键字
最新推荐文章于 2024-07-08 11:35:15 发布
扫一扫
426
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
