c 点滴——————

最新推荐文章于 2023-11-06 19:53:27 发布

csdn_dx

最新推荐文章于 2023-11-06 19:53:27 发布

阅读量904

点赞数

分类专栏： C 语言 stm32 文章标签： c语言单片机 stm32

本文链接：https://blog.csdn.net/u011041241/article/details/78502546

版权

C 语言同时被 2 个专栏收录

23 篇文章 2 订阅

订阅专栏

stm32

12 篇文章 0 订阅

订阅专栏

(1)各系统中int位数不同。

在stm32里面int是有符号数32位，在dsp里面int是16位，51单片机也是16位的。考虑程序的可移植性，要将u8,u16,u32 宏定义下。如果你在stm32中用，unsinged int testaa；那么移植到单片机中，就会溢出。

(2)有符号数补码存储

C语言中，有符号数8位，范围是-128----127，内存中存储是补码形式存储的，最高位位是符号位，127存的是0111 1111

在加1就是1000 0000 ，十进制是-128。

-1（原码是 1000 0001，反码1111 1110，补码1111 1111）在内存中是0xFF；

问题：有符号数和无符号数如何相加，

uchar_c，uchar_b是无符号数，char_d是有符号数 ;

   125:   uchar_c=char_d+uchar_b; 
   126:    
C:0x04C0    E53B     MOV      A,char_d(0x3B)
C:0x04C2    252E     ADD      A,uchar_b(0x2E)
C:0x04C4    F52F     MOV      uchar_c(0x2F),A

char_d有符号数，直接用补码和无符号数相加

问题， u8（无符号数8位，0---255）， 1-254=？？？？结果也存在u8里面

char_d=1，uchar_b=254，

   125:   char_c=char_d-uchar_b; 
   126:    
C:0x04C0    C3       CLR      C
C:0x04C1    E53C     MOV      A,char_d(0x3C)
C:0x04C3    952E     SUBB     A,uchar_b(0x2E)
C:0x04C5    F539     MOV      char_c(0x39),A

根据反汇编，0000 0001 - 1111 1110 = 0000 0011（舍掉了借位）

也有人这样理解，计算机里面只做加法（这个不知道是不是真的？？），所以（-254）的补码是0000 00010 在加0000 0001 是0000 0011；所以答案是3

可利用之处：

这样stm32的定时器是16位的，最大值是65535，在俩个时刻分别存储cnt，在一个周期内，俩个cnt不用判断谁大谁小，直接用后一个cnt减去前一个cnt。得到的是俩个时间差

spwm读表的时候，可以把表做成2的n次方。这样就可以不用管counter的溢出了，比如用了256个点的正弦表，counter++；把counter做成u8就够了，不用判断表是否溢出

(3)一地址一字节

内存一般一个地址对应一个字节，一个字节为八位，如0x08010000中存放的是unsigned char；

再比如W25Q16有16Mbit存储位，
因为1024bit就是1K, 16Mbit =16*1024*1024=16 777 216 bit，从手册存储器结构图可以看出W25Q16的最大地址值是1FFFFFH，24位地址高3位固定为0（W25X64才需用到最高3位），只有21位有效地址，2的21次方=2097152字节，2097152个字节正好存储16 777 216bit，这里的地址都是以字节为最小单位的。

(4)枚举

占用的是同一个空间，枚举是用逗号隔开，枚举只能赋值其中的枚举类型，不然编译器会报错；

(5)sprint带%X

sprint可以带%X 直接转换成16进制；

(6)来自笔试题

用变量a 给出下面的定义
e) 一个有10个指针的数组，该指针是指向一个整型数的;
f) 一个指向有10个整型数数组的指针;
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数;
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数;
【标准答案】 e)int * a[10]; f)int (*a)[10] g)int (*a)(int); h) int (*a[10])(int)

下面的代码输出是什么，为什么？
void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b> 6)? puts("> 6") : puts("<= 6");
}
【参考答案】这个问题测试你是否懂得C 语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是“>6” 。原因是当表达式中存在有符号类型和无符号类型时所有的数都自动转换为无符号类型。因此-20 变成了一个非常大的正整数，所以该表达式计算出的结果大于6 。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

printf("b=%u\n", b); //b=4294967276

a+b = 6+(-20) = 6 + 4294967276 = 4294967282

(7)函数指针数组

int add(int a,int b)
{
return a+b;
}

int mul(int a, int b)
{
return a*b;
}

void main ()
{
   int anum,bnum;
   int (*pn[2])(int, int);                       //定义函数指针数组，第一个int是函数的返回类型
   pn[1]=add;                                   //*pn是函数指针的变量名，（int，int）是函数的形参类型
   pn[2]=mul;
   anum=pn[1](1,2);
   bnum=pn[2](1,4);
}

在函数较多，实现的功能较多的时候，可采用函数指针数组的方式，通过循环，操作不同的函数

（8）全局变量，静态全局变量，局部变量，静态局部变量

静态局部变量是在函数中的局部变量前面加static。

静态全局变量是在全局变量前面加static。

static 限制变量作用域，函数体中的静态局部变量只作用与该函数体内。

（9）指针定义的时候可以不初始化，使用的时候一定要初始化，

在stm32中未给定地址，结果进入HardFault_Handler中断中导致错误

如下，定义结构体

typedef struct
{
float Resistance;
float Temperature;
}NTC;

typedef NTC *NTC_handle;

NTC Ntc[3];//结构体指针数组
NTC_handle NTC_a[3]={&Ntc[0],&Ntc[1],&Ntc[2]}; //NTC_a[3]是指向结构体的指针数组，使用时一定要初始化，实测用null初始化也会进入HardFault_Handler；

（10）math中的对数运算

void NTC_Compute_Temper(NTC *V)
{
V->Temperature =1/(log(V->Resistance/R_T25)/NTC_B+0.003354)-273.15;
}

NTC_Compute_Temper(NTC_a[0]);

利用热敏电阻的B值计算当前温度的时候

log（）是以e为底

log10（）是以10为底

double pow(double x,double y);计算x的y次幂
float powf(float x,float y); 功能与pow一致，只是输入与输出皆为浮点数
double exp (double);求取自然数e的幂
double sqrt (double);开平方

（11）#define VADC_REF (33/10)宏定义

宏定义本来想定义3.3，采用宏定义#define VADC_REF (33/10)

实际计算采用如下公式，

(float)(ADC_Value)/VADC_REF*10000/(1-ADC_Value/VADC_REF);

本理解宏定义是文字代替，这样就ADC_Value/33/10 就相当于/3.3 实际追踪内存，发现内存中存放的是3 并且有实际地址

猜测应该在预编译中当做常量来处理了，

（12）宏定义多条语句格式

宏定义多条语句可以用如下的形式进行定义：
#define swap(a,b) { a = a + b; b = a - b; a = a - b; }
// 如果分行写，可以写成如下形式
#define swap(a,b) { a = a + b;\
b = a - b;\
a = a - b;}
宏定义一般分为带参宏定义和不带参宏定义。

带参宏定义，也即带参数的宏定义，如：
#define MAX(a,b) ((a)>(b) ? (a) : (b)) // 求最大值

不带参宏定义，也即不带参数的宏定义，如：
#define PI 3.14159 // 定义圆周率pi的值

注意宏定义中写错语句，语法错误等，编译器（mdk5）不会报错，所以宏定义时一定要注意。

（13）数据类型与typedef

在编程的世界中程序员是上帝，用代码创造各个世界，上帝造出了自然法则，各世界都得顺从。

上帝造万物的时候也给万物了类型，如人，狗，草，树等类型，

在C语言中数据类型有基本的int 、char 等，也有其他复杂的类型，指针，数组等

char array[20]，类型是 char[20];

int* p,类型是int*；

int （*p）（int int），类型是int （*）（int int）；

使用typedef：

typedef char ARRAY[20]；可以定义ARRAY a1，a2；a1，a2也是char 数组。

typedef int* P；可以定义P a1，a2；a1，a2也是int指针。

typedef int （*P）（int int）；可以定义P a1，a2；a1，a2也是函数指针。

typedef int (*PTR_TO_ARR)[4];表示 PTR_TO_ARR 是类型int * [4]的别名，它是一个二维数组指针类型。接着可以使用 PTR_TO_ARR 定义二维数组指针：

PTR_TO_ARR p1, p2;

（14）51单片机中printf不正确，

上述指明 %d 和%u 是读取16位整形，如果需要打印%d则需要明确指明数据类型。如（unsigned int）3。

（15）sizeof()和strlen的区别

sizeof()是运算符，在头文件的类型为unsigned int,其运算值在编译时就计算好了，参数可以是指针、数组、类型、对象和函数等；strlen()是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化为指针了。该函数完成的功能是从代表该字符串的第一个地址开始遍历的，直到遇到结束符NULL。返回的长度大小不包括NULL。

举个例子：
char str[20] = “0123456789”;
int a = strlen(str);
int b = sizeof(str);

a = 10,b = 20;因为strlen计算的是字符串的长度，以’\0’为字符串结束标志；而sizeof计算的是分配的数组str[20]所占的内存空间的大小，不受里面存储的内容影响。

再比如：
char *str1 = “abcde”;
char str2[] = “abcde”;
char str3[8] = {‘a’};
char ss[] = “0123456789”;

其计算结果为：
sizeof(str1) = 4;
sizeof(str2) = 6;
sizeof(str3) = 8;
sizeof(ss) = 11;

str1 是一个指针，只是指向了字符串"abcde"而已。所以sizeof(str1)不是字符串占的空间也不是字符数组占的空间，而是一个指针所占的空间。在C/C++中一个指针占四个字节。
str2是一个字符型数组，对于一个数组，返回这个数组所占的总空间，所以sizeof(str2)取得的是字符串"abcde"的总空间。"abcde"中，共有a b c d e \0六个字符，所以str2数组的长度时6,。
str3已经定义成了长度为8的数组，所以sizeof(str3)为8；
str4和str2类似，共十一个字符，所以ss所占的空间是11.

具体而言，当参数分别是如下时，sizeof返回的值表示的含义如下：
数组----编译时分配的数组空间的大小；
指针----存储该指针所用的空间的大小（存储该指针的地址的长度，是长整型，应该是4）；
类型----该类型所占的空间的大小；
对象----对象的实际占用空间大小；
函数----函数的返回类型所占的空间大小。函数的返回类型不能是void。

再举个列子：
对于指针：
char *ss = “0123456789”;
sizeof(ss)结果是 4 ==》 ss是指向是字符串常量的字符指针，sizeof获得的是第一个指针所占的空间，应该是长整型，所以是4；
sizeof(*ss)结果是1 ==》 *ss是第一个字符，其实就是获得了字符串的第一位’0’多占的内存空间，是char类型的，占了1位。
strlen(ss) = 10 ==》如果要获得这个字符串的长度，则一定要用strlen。
————————————————
版权声明：本文为CSDN博主「菜鸟·博客」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/songjiasheng1314/article/details/88644827

（16） sprintf 代码量
sprintf(StringBuff_C1,"%s=%.3f",ss,sss);

编译后代码量code 4005

屏蔽编译后，code 1448

内存少的需要慎重

（17）单片机c语言中unsigned char 和unsigned char 相乘后溢出，是如何处理

uchar_x 均表示无符号数

   125:    uchar_c=uchar_a*uchar_b; 
   126:    
C:0x04C0    E52D     MOV      A,uchar_a(0x2D)
C:0x04C2    852EF0   MOV      B(0xF0),uchar_b(0x2E)
C:0x04C5    A4       MUL      AB
C:0x04C6    F52F     MOV      uchar_c(0x2F),A

由反汇编可知（uchar_c，uchar_a，uchar_b;定义为全局变量，这样在keil中反汇编为变量名（）），采用MUL AB， MUL指令将累加器A和寄存器B中两个8位数进行相乘，结果为16位，低八位在A中，高八位在B中。结果大于0xff则溢出，溢出标志位OV置位，否则清0。

可知：C语言中，俩个8位相乘，需要注意溢出问题。

如果结果赋值给16位数据，汇编又是如何操作的呢？

如下，ushort_c 是16位

   128:    ushort_c=uchar_a*uchar_b; 
   129:    
C:0x04C0    E52D     MOV      A,uchar_a(0x2D)
C:0x04C2    852EF0   MOV      B(0xF0),uchar_b(0x2E)
C:0x04C5    A4       MUL      AB
C:0x04C6    85F03D   MOV      ushort_c(0x3D),B(0xF0)
C:0x04C9    F53E     MOV      0x3E,A

由反汇编可知，MUL AB 后，自动地址加一，存储A的内容，同时可得B（高八位）在地址低位，A（低八位）在地址高位。单片机是大端模式

附大端和小端

举一个例子，比如数字0x12 34 56 78在内存中的表示形式。

1)大端模式：Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

（其实大端模式才是我们直观上认为的模式，和字符串存储的模式差类似）

低地址 --------------------> 高地址
0x12 | 0x34 | 0x56 | 0x78

2)小端模式：Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

低地址 --------------------> 高地址
0x78 | 0x56 | 0x34 | 0x12

（18）给指针赋值字符串引发的问题

如：

初始化赋值char *p=“abcd”；

双引号做了3件事：
1.申请了空间(在常量区)，存放了字符串
2. 在字符串尾加上了'/0'
3.返回地址

所以 *p="dcba" 是不能修改常量区的内容的，但是能编译通过，运行会出问题，所以初始化最好加上const表明，如const char *p=“abcd”；这样程序中修改，编译是通不过的。

要想修改内容，定义如下

char a[10] = “hello”;

char *p=a；

然后

*p="dcba" 就可以了

（19）char *p = “hello”;

char *p = “hello”;

上边的表达式为什么可以，而把p换成数组，然后再赋值就不行了

解释：

字符串常量"hello"出现在一个表达式中时，"hello"表达式使用的值就是这些字符所存储的地址（在常量区），而不是这些字符本身。所以，可以把字符串赋值给指向字符的指针p，而不能把字符串赋值给一个字符数组。

char a[10] = “hello”; //这样可以，这种情况是c语言初始化所支持的

如果写成char a[10]然后 a = “hello” 这样就错误了。

同样是a数组，char a[10] = “hello”;这种是数组的初始化，和a[0] = ‘h’ a[1] = ‘e’…是一个道理

但是换成char a [10]，然后a = “hello”就不行了 “hello”赋值的值是一个地址，而a虽然也有地址，但是这与指针是不一样的，指针的值是地址，而数组的值虽然也是地址，但是却是一个常量，所以不能给常量赋值！！！！

（20）数组做形参

  unsigned char aa[]={1,2,3,4,22,3,5,0,0};
  test_array(aa);
  void test_array(unsigned char array[])
{
  while(*array++)
  {
    printf("array=%d\r\n",(unsigned int)*array);
   if(*array>20)
   {
     return;  
   }
  }
}

输出

上面的*array++，是先计算array++，然后*取内容(++和*是同一优先级，自右向左运算)，此时array已经退化成指针变量了。才可以对数组名退化的指针变量进行加加操作

需要注意while（*array）里面如果有0，则停止循环，此处数组中有0；

（21）以下摘自其他网站

1. C语言中没有字符串类型，只有用字符数组来表示。这和c++中string是有区别的，C++中string是可以直接赋值如string s;s="Hello world";但是C语言中的字符数组却不能这样。所以，这里的strTmp可以理解为字符数组的首地址，也可以用它代表整个字符数组，所以能输出所有字符数组中的内容。

2.字符串就是字符数组或者是指针。内存实现都一样的。数组名字就是一个指针。

char ch[100] ;
char *p;
p =ch;

3.定义的字符串方式举例：

字符串定义其实很简单在c/c++语言中定义一个字符串可以使用如下的语法：

char *s1=“string1”；//定义字符串常量，指针形式

char s2[]=“string2”；//定义字符串常量，数组形式

char *s3=new char[10]；//定义字符串变量并分配内存指针形式

strcpy(s3,"string3");//为s3赋值

char s4[10]；//定义字符串变量，数组形式

strcpy(s4,"string4");//为s4赋值

以上四种方法都能定义一个字符串，同时通过字符串在内存中的分布可以清楚地知道是什么情况

4. C语言中字符串赋值方法strcpy(char*d,char*s)其中s代表是源字符串，d代表目标字符串，也就是你要赋值的字符串。

5.c语言中的字符串跟java或c++中的字符串不同。如char *p；其中p是一个指针，p中存储一个内存缓冲区的首地址。所谓的内存缓冲区就是一段连续的内存地址，里面存放了一系列的字符。那系统又是如何判断在哪里结束呢。那就是根据符号‘\0’。这个字符占一个字节，8位，每位的值都是0。

（22）goto 不能跨函数使用，只能在函数内部

(23)结构体存储入FLASH

有些时候，需要将对整个结构体存储到FLASH中，如下

WriteMulti_flash(PAGE(writePage_no),&fdb_writeTemp,sizeof(fdb_writeTemp));

fdb_writeTemp 是一个结构体，里面有整形和浮点型数据。该函数的实现是：

void WriteMulti_flash(const uint32 addr,FDB_P writeReg,uint8 lenOfWrite)
{
SPI_Flash_Write_NoCheck((uint8*)writeReg,addr,lenOfWrite);
}

FDB_P 的定义是，

typedef struct
{
uint8 used;
uint8 writeCnt;
uint16 page_no;
DATA_T dataHis;

}FDB;

typedef FDB* FDB_P; 注意typedef FDB* FDB_P; *是和FDB是一体的，如type int* int_p；（原先理解成*int_p.然后再写的时候又写， int_p=&a，就比较混乱，难以言表这种理解错误。当int* 理解成一个整体就好了。这个理解的太晚了。给自己瞎说的）

SPI_Flash_Write_NoCheck((uint8*)writeReg,addr,lenOfWrite); 存储的时候，将writeReg 指针类型转换成了uint8* 这样在函数SPI_Flash_Write_NoCheck内，对*writeReg++，就表示一次只加八个字节的地址。

在flash中读取的时候，如下

ReadMulti_flash(PAGE(writePage_no),&fdb_readTemp,sizeof(fdb_readTemp));

实现如下

void ReadMulti_flash(const uint32 addr,FDB_P readReg,uint8 lenofRead)
{
SPI_Flash_Read((uint8*)readReg,addr,lenofRead);
}

此处同样是将readReg 转换成了(uint8*)。

在 SPI_Flash_Read 内部是有如下部分代码。

for(i=0;i<Len;i++)
{
*pbuf++=SPI_ReadByte();
}

这样每次pbuf++ 就增加一个八字节。读出来的字节，就给到对应的地址，

如果是float型，占用四个字节，写的时候，直接将这四个字节拆分挨个写进去，读取的时候，挨个读出来，组装成float。

sizeof(readReg)=3 sizeof 指针，在单片机中是三个字节三个字节，三个字节，应该是单片机取址有限，设计成为三个字节存储指针