将十进制转换为十六进制,八进制,二进制的函数。

#include<stdio.h>
#include<string.h>
void reverseString(char *s)
{
    int i;
    int len = strlen(s);
    for(i = 0;i < len / 2;++i)
    {
        char t;
        t = s[i];
        s[i] = s[i - len - 1];
        s[i - len - 1] = t;
    
    }
    
}
void itoa(unsigned int n,int num)
{
    char s[100];
    char *p = s;
    while(n)
    {
        int t;
        t = n % num;
        if(t >= 10)
        {
            *p = t + 55;
        }
        else
        {
            *p = t + '0';
        }
        n = n / num;
        ++p;
    }
    *p = '\0';
    reverseString(p);
    puts(s);
}

int main(void)
{
    itoa(1234,16);
    return 0;
}

结构体

在C语言中,结构体是一种复合数据类型,允许你将多个不同类型的数据项组合成一个单一的类型。这使得你可以将相关数据组织在一起,以便于管理。

声明一个结构体类型的一般形式:struct        结构体名

                                                      {成员表列};

struct student
{
    int id;
    char name[100];
    float score;
};

例如该结构体,它指定了一个新的结构体类型struct  student是一个类型名,它与系统提供的标准类型一样并具有相同的作用,都是用来定义标量的类型 

它包括了三个成员一个整数id,一个字符串name,一个浮点数score

1.定义结构体类型变量的方法

(1)如上面已经定义了一个结构体类型struct  student,可以用它来定义变量。

例如:struct  student        student1,student2。

在定义了变量之后系统会为其分配内存单元

(2).在声明类型的同时定义变量

struct student
{
    int id;
    char name[100];
    float score;
}student1,student2;

它的作用与第一种方法相同。

(3).直接定义结构体类型变量

其一般形式为:struct

                         {

                          成员表列

                          }变量名表列;

结构体类型:类型与变量是不同的概念,只能对变量赋值,存取或运算,而不能对一个类型进行赋值,存取或运算。在编译的过程中,对类型是不分配空间的,只对变量分配空间。

2.结构体变量的引用

在引用结构体变量时,不能将一个结构体变量作为一个整体进行输入和输出。只能对结构体当中的各个成员进行输入或输出。

引用结构体变量中成员的方式为:结构体变量名.成员名

例如,student1.id表示student变量当中的id成员可以对其进行赋值    student1.id = 2

结构体变量的成员可以像普通变量一样进行各种运算。

可以引用结构体变量成员的地址,也可以引用结构体变量的地址。

结构体变量的地址主要用做函数参数,传递结构体变量的地址。

void printstudent(struct student *p)
{
    printf("%d %s %f \n",p->id,p->name,p->score);
}
void printstudents(struct student *a,int len)
{
    int i;
    for(i = 0;i < len;++i)
    {
        //printstudent(a + i);
        printstudent(&a[i]);
    }
}
 3.结构体变量的初始化

和其他类型一样,在定义时可以对结构体变量指定初始值

int main(void)
{
    struct student a[3] = {
    {1,"zhang",92},
    {2,"li",95},
    {3,"wang",97},
    }; 
    int len = sizeof(a) / sizeof(*a);
   // reversestudent(a,len);
   // sortstudentByName(a,len);
   // sortstudentByScore(a,len);
    sortstudent(a,len,scorecmp);
    printstudents(a,len);

    return 0;
}
4. 结构体数组和指向结构体类型的指针

结构体数组与之前的数值型数组不同之处在于每个数组元素都是一个结构体类型的数据,他们都包括各个成员项。

一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设置一个指针变量,用来指向一个结构体变量,此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组当中的元素。

void swap(struct student *a,struct student *b)
{
    struct student t;
    t = *a;
    *a = *b;
    *b = t;
}
void reversestudent(struct student *a,int len)
{
    int i;
    for(i = 0;i < len / 2;++i)
    {
        swap(a + i,a + len - i - 1);
    }
}
int namecmp(struct student *p1,struct student *p2)
{
    return strcmp(p1->name,p2->name); 

}
int scorecmp(struct student *p1,struct student *p2)
{
    if(p1->score > p2->score)
    {
        return 1;
    }
    else if(p1->score == p2->score)
    {
        return 0;
    }
    else
    {
        return -1;
    }
}
void sortstudent(struct student *a,int len, int (*pfn)(struct student *,struct student *))
{
    int i,j;
    for(i = 0;i < len - 1;++i)
    {
        for(j = i + 1;j < len;++j)
        {
            if((*pfn) > 0)
            {
                swap(a + i,a + j);
            }
        }

    }
}
void sortstudentByName(struct student *a,int len)
{
    int i,j;
    for(i = 0;i < len - 1;++i)
    {
        for(j = i + 1;j < len;++j)
        {
            if(strcmp(a[i].name,a[j].name) > 0)
            {
                swap(a + i,a + j);
            }
        }
    }
}
void sortstudentByScore(struct student *a,int len)
{
    int i , j;
    for(i = 0;i < len - 1;++i)
    {
        for(j = i + 1;j < len;++j)
        {
            if(a[i].score > a[j].score)
            {
                swap(a + i,a + j);
            }
        }
    }

}
int main(void)
{
    struct student a[3] = {
    {1,"zhang",92},
    {2,"li",95},
    {3,"wang",97},
    }; 
    int len = sizeof(a) / sizeof(*a);
   // reversestudent(a,len);
   // sortstudentByName(a,len);
   // sortstudentByScore(a,len);
    sortstudent(a,len,scorecmp);
    printstudents(a,len);

    return 0;
}

结构体中成员的在地址当中的位置

(1)默认按cpu位数对齐:8字节最终的大小必须是8的整数倍

(2)在结构体成员中找到最长成员,最终按照该成员长度对齐;

(3)按照结构体声明的顺序,依次将成员保存到结构体内存中,保存的偏移量/sizeof(成员) == 0

结构体变量所占的内存长度是各成员占的内存长度之和。

共用体 

共用体是将几种不同类型的变量存放在同一段内存单元当中。变量在内存中占用的字节数不同,但都从同一地址开始存放,也就是使用覆盖技术,几个变量互相覆盖。

定义共用体的一般形式:union  共用体名

                                        {成员表列

                                        }标量表列;

共用体变量所占的内存长度等于最长的成员的长度。

union demo
{
    int i;
    char s;
};
int main(void)
{
    union demo d;
    d.i = 1;
    if(d.s == 1)
    {
        printf("xiaoduan\n");
    }
    else
    {
        printf("daduan\n");
    }

}

共用体类型数据的特点:

1.同一段内存段可以用来存放几种不同类型的成员,但在一瞬间只能存放其中一种,而不是同时存放几种 

2.共用体变量中起作用的成员是最后一字存放的成员,存入一个新的成员后原有的成员就失去了作用

3.共用体变量的地址和它的各成员地址都是同一地址。

枚举类型

如果一个变量只有几种可能的值,则可以定义为枚举类型。所谓的枚举是指将变量的值一 一列举出来,变量的值只限于列举出来的值的范围内。

enum Week
{
	Sun, Mon, Tue = 7, Wes, Thu, Fri, Sat
};

int main(void)
{
	enum Week w;
	w = Sun;
	
	printf("%d\n", w + 1);

/*	switch(w)
	{
	case Sun:
		puts("lol");
		break;
	case Mon:
	case Tue:
		puts("study");
		break;
	default:
		break;
	}*/

	return 0;
}

用typedef定义类型 

可以用typedef声明新的类型来替代已有的类型名

typedef int INT;

typedef struct Demo
{
	int i;
	short s;
	char c;
}Demo, *PDEMO;

typedef void (*pfn)(void);
typedef pfn ARRAY[10];


int main(void)
{
	ARRAY a;
	printf("%lu\n" ,sizeof(a));
	return 0;
}

位运算 

位运算是指进行二进制的位运算

1.“按位与”运算符

如果两个相应的二进制位都为1,则改为的结果为1,否则为0

0 & 0 = 0,        0 & 1 = 0,        1 & 0 = 0,        1 & 1 = 1

如果参与运算的为负数,则以补码的形式表示二进制。

2.“按位或”运算符

两个相应的二进制位中只要有一个为1,该位的结果为1

0 | 0 = 0,        0 | 1 = 1,        1 | 0 = 1,        1 | 1 = 1

3.“异或”运算符

若参加运算的两个二进制位同号,则结果为0;异号结果为1

0 ^ 0 = 0,        0 ^ 1 = 1,         1 ^ 0 = 1,        1 ^ 1 = 0

4.“取反”运算符

用来对一个二进制数按位取反,即将0变1,1变0。

※5.“左移”运算符

用来将一个二进制数的各二进制全部左移若干位。

例如:a = a <<2        将a的二进制数左移两位,右补0

6.“右移”运算符

a >>2表示将a的各二进制位右移2位,移到右端的低位被舍弃,对无符号数,高位补0

int main(void)
{
	unsigned char P2 = 0xAA;
	P2 &= 0xEF;

	return 0;
}


int main(void)
{
	int i = 0xFFFFFFFF;
	i <<= 2;
	printf("%X\n", i);

	return 0;
}
#endif


int main(void)
{
	unsigned char P0 = 0xFF;
	
	P0 &= ~((1 << 3) | (1 << 5));
//	P0 |= (1 << 2) | (1 << 0);
	printf("%X\n", P0);

	return 0;
}

 

    

 

 

 

 

 

更多推荐