其他分享
首页 > 其他分享> > C语言学习笔记—P16(结构体+图解+题例)

C语言学习笔记—P16(结构体+图解+题例)

作者:互联网

 

题例讲解:

T1.

#include <stdio.h>
int main()
{
	int a, b, c;

	a = 5;//a=5
	c = ++a;//c=6  a=6
	b = ++c, c++, ++a, a++;
	//b=7 c=8 a=8
	b += a++ + c;
	//b=23 a=9 c=8
	printf(" a = %d\n b = %d\n c = %d\n:", a, b, c);//9 23 8
	return 0;
}

 T2.

统计二进制中1的个数
int count_number_of_1( int m)
{
	int c = 0;
	while (m)
	{
		if (m % 2 == 1)
		{
			c++;
		}

		m /= 2;
	}
	return c;
}
int main()
{
	int n = 15;//n放在内存中的补码的2进制中1的个数
	int ret = count_number_of_1(n);
	printf("%d\n", ret);
	return 0;
}

 对于负数会失效!

  适用于负数解决方法一:

使用unsigned ,主函数中n为-1,是有符号位,但定义函数中的m不希望是有符号位,因此在将n传给m的时候,使用unsigned默认传过去的是无符号位的整数的补码,其所有的位都是有效位。

注:使用-1的绝对值不行,求解补码的1的个数,逻辑就不通!

int count_number_of_1(unsigned int m)
{
	int c = 0;
	while (m)
	{
		if (m % 2 == 1)
		{
			c++;
		}

		m /= 2;
	}
	return c;
}
int main()
{
	int n = -1;//n放在内存中的补码的2进制中1的个数
	//10000000000000000000000000000001
	//11111111111111111111111111111110
	//11111111111111111111111111111111 -> -1的补码

	int ret = count_number_of_1(n);
	printf("%d\n", ret);
	return 0;
}

 适用于负数解决方法二:

int count_number_of_1(int m)
{
	int c = 0;
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		if ((m & 1) == 1)
		{
			c++;
		}
		m >>= 1;
	}
	return c;
}

int main()
{
	int n = -1;//n放在内存中的补码的2进制中1的个数
	//10000000000000000000000000000001
	//11111111111111111111111111111110
	//11111111111111111111111111111111 -> -1的补码

	int ret = count_number_of_1(n);
	printf("%d\n", ret);
	return 0;
}

 适用于负数解决方法三:

int count_number_of_1(int m)
{
	int c = 0;//计数器
	while (m)
	{
		m = m & (m - 1);
		c++;
	}
	return c;
}
int main()
{
	int n = -1;//n放在内存中的补码的2进制中1的个数
	//10000000000000000000000000000001
	//11111111111111111111111111111110
	//11111111111111111111111111111111 -> -1的补码

	int ret = count_number_of_1(n);
	printf("%d\n", ret);
	return 0;
}

 

 判断一个数m是不是2的k次方,可以使用m&(m-1)==0

 在线刷题形式:

 

T3.

 

 


int count_diff_bit(int m, int n)
{
	int i = 0;
	int c = 0;//计数器
	for (i = 0; i < 32; i++)
	{
		if ((m & 1) != (n & 1))
		{
			c++;
		}
		m >>= 1;
		n >>= 1;
	}
	return c;
}
int main()
{
	int m = 1999;
	int n = 2299;

	int ret = count_diff_bit(m, n);
	printf("%d\n", ret);
	return 0;
}

  方法一:

 方法二:

//异或操作符
//相同为0,相异为1
int count_diff_bit(int m, int n)
{
	int i = 0;
	int c = 0;//计数器
	int tmp = m ^ n;
	//计算tmp的二进制位中有几个1
	while (tmp)
	{
		tmp = tmp & (tmp - 1);
		c++;
	}
	return c;
}

int main()
{
	int m = 1999;
	int n = 2299;

	int ret = count_diff_bit(m, n);
	printf("%d\n", ret);
	return 0;
}

每天坚持学习,脑结构会改善哦!

T4.

//题目名称:
//打印整数二进制的奇数位和偶数位
//题目内容:
//获取一个整数二进制序列中所有的偶数位和奇数位,分别打印出二进制序列
//
void print(int m)
{
	//打印奇数位
	int i = 0;
	for (i = 30; i >= 0; i -= 2)
	{
		printf("%d ", (m >> i) & 1);
	}
	printf("\n");
	//打印偶数位
	for (i = 31; i >= 1; i -= 2)
	{
		printf("%d ", (m >> i) & 1);
	}
}

int main()
{
	int m = 0;
	//
	//00000000000000000000000011001001
	//
	
	scanf("%d", &m);
	print(m);
	return 0;
}

 go语言!

T5.

int i;//全局变量,不初始化的话,默认是0
int main()
{
    i--;//-1
    if (i > sizeof(i))//-1 > 4
    {
        printf(">\n");
    }
    else
    {
        printf("<\n");
    }
    return 0;
}

  

 

 -1被当成一个无符号位后,其值为4294967295

 T6.

 


int main()
{
    int n = 0;
    //EOF - end of file
    //
    while (scanf("%d", &n) != EOF)
    {
        if (n % 2 == 1)
        {
            printf("Odd\n");
        }
        else
        {
            printf("Even\n");
        }
    }


    return 0;
}

 

 T7.

 

 在Visual Stdio 2019运行示例:

 输入A和b 的顺序为:先输入A再 空格(\n)再输入b,

当scanf读取的时候,第一个字符正常读取,但会在缓冲区读取\n,传给&ch,而\n既不是元音也不是辅音,则总输出的结果与预期不符!

 

 方法一:使用getchar()

因为是单次输入,则没使用getchar循环:

int main()
{
    char v[] = { 'a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U' };

    char ch = 0;
    while (~scanf("%c", &ch))
    {
        int i = 0;
        for (i = 0; i < 10; i++)
        {
            if (ch == v[i])
            {
                printf("Vowel\n");
                break;
            }
        }
        if (i == 10)
            printf("Consonant\n");
        //清理缓冲区
        getchar();//\n
    }

    return 0;
}

 方法二:scanf使用%c   仅限于拿字符的时候拿走\n,而不适用于打印整型!因为拿字符会将缓冲区的任何东西都当做字符处理!

 方法三:见下图

 

 

 去大企业实习!

正确评估某一件事情!

7- 结构体 1. 结构体的声明

 1.1 结构的基础知识

结构是一些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量。 1.2 结构的声明

 

struct tag
{
 member-list; 
}
variable-list;

 例如描述一个学生:

typedef struct Stu
{
 char name[20];//名字
 int age;//年龄
 char sex[5];//性别
 char id[20];//学号
}Stu;//分号不能丢

 

 

 

1.3 结构成员的类型 结构的成员可以是标量、数组、指针,甚至是其他结构体。 1.4 结构体变量的定义和初始化 有了结构体类型,那如何定义变量,其实很简单。
struct Point
{
 int x;
 int y; }p1;                      声明类型的同时定义变量p1
struct Point p2;                  定义结构体变量p2
                                  初始化:定义变量的同时赋初值。
struct Point p3 = {x, y};
struct Stu                        类型声明
{
 char name[15];                   名字
 int age;                         年龄
};
struct Stu s = {"zhangsan", 20};  初始化
struct Node
{
 int data;
 struct Point p;
 struct Node* next;    
}n1 = {10, {4,5}, NULL};                结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};    结构体嵌套初始化
   
struct Stu
{
	char name[20];
	int age;
	float score;
}s1, s2;                                           s1,s2是2个结构体变量,是全局的

int main()
{
	int a = 0;
	int b = 0
	struct Stu s = { "zhansan", 20, 95.5f };       定义一个结构体变量,局部的
	printf("%s %d %f\n",  s.name, s.age, s.score);
	return  0;
}

 

 
struct S
{
	int a;
	char c;
	double d;
};

struct Stu
{
	struct S ss;
	char name[20];
	int age;
	float score;
}s1, s2;//s1,s2是2个结构体变量,是全局的

int main()
{
	int a = 0;
	int b = 0;

	struct Stu s = { {100, 'w', 3.14}, "zhansan", 20, 95.5f};//定义一个结构体变量,局部的
	printf("%d %c %lf %s %d %f\n",s.ss.a, s.ss.c, s.ss.d, s.name, s.age, s.score);

	return  0;
}

 

2. 结构体成员的访问 结构体变量访问成员 结构变量的成员是通过点操作符(.)访问的。点操作符接受两个操作数

 例如:

struct Stu
{ 
   char name[20];
    int age;
};

struct Stu s;

  

我们可以看到 s 有成员 name 和 age ; 那我们如何访问 s 的成员?
struct S s;
strcpy(s.name, "zhangsan");    使用.访问name成员
s.age = 20;                    使用.访问age成员
结构体指针访问指向变量的成员 有时候我们得到的不是一个结构体变量,而是指向一个结构体的指针。 那该如何访问成员。 如下:
struct Stu
{
 char name[20];
 int age;
};
void print(struct Stu* ps) {
 printf("name = %s   age = %d\n", (*ps).name, (*ps).age);
                            使用结构体指针访问指向对象的成员
 printf("name = %s   age = %d\n", ps->name, ps->age);
}
int main()
{
    struct Stu s = {"zhangsan", 20};
    print(&s);              结构体地址传参
    return 0; }

3. 结构体传参

 

struct S {
 int data[1000];
 int num;
};
struct S s = {{1,2,3,4}, 1000};

结构体传参
void print1(struct S s) {
 printf("%d\n", s.num);
}

结构体地址传参
void print2(struct S* ps) {
 printf("%d\n", ps->num);
}

int main()
{
 print1(s);      传结构体
 print2(&s);     传地址
 return 0; }

   

 

上面的 print1 和 print2 函数哪个好些? 答案是:首选 print2 函数。 原因: 函数传参的时候,参数是需要压栈的。 如果传递一个结构体对象的时候,结构体过大,参数压栈的的系统开销比较大,所以会导致性能的 下降。   

struct S
{
	int arr[1000];
	float f;
	char ch[100];
};

void print(struct S tmp)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", tmp.arr[i]);
	}
	printf("\n");
	printf("%f\n", tmp.f);
	printf("%s\n", tmp.ch);
}

int main()
{
	struct S s = { {1,2,3,4,5,6,7,8,9,10}, 5.5f, "Hello,World!" };
	print(s);
	return 0;
}

 

 

优化:

struct S
{
	int arr[1000];
	float f;
	char ch[100];
};

void print1(struct S tmp)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", tmp.arr[i]);
	}
	printf("\n");
	printf("%f\n", tmp.f);
	printf("%s\n", tmp.ch);
}

void print2(struct S* ps)
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
	printf("%f\n", ps->f);
	printf("%s\n", ps->ch);
}

int main()
{
	struct S s = { {1,2,3,4,5,6,7,8,9,10}, 5.5f, "hello bit" };
	//print1(s);
	print2(&s);
	return 0;
}

 

 


 


int Add(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}

int main()
{
	int a = 10;
	int b = 20;
	int c = Add(a, b);
	
	printf("%d\n", c);

	return 0;
}

 函数调用过程解析——函数栈帧的创建于销毁见下节笔记!

 

结论: 结构体传参的时候,要传结构体的地址。

  

 

 

 

 

 

 

标签:题例,return,struct,int,C语言,P16,printf,main,name
来源: https://blog.csdn.net/m0_57859086/article/details/121449763