C – 微宇宙

探讨C语言返回struct的实现

C语言基本类型的返回通过寄存器实现。

寄存器容量不大，一个结构体的大小不定，多塞几个成员，很容易就会超过寄存器的容量，不太可能通过寄存器一次性返回一个结构体。

把以下代码转为汇编，探个究竟:

// return_struct.c

struct the_struct {
        int num1;
        int num2;
        double num3;
        double num4;
        int *num_ptr1;
        int *num_ptr2;
};

struct the_struct fun() {
        struct the_struct the_struct1;
        the_struct1.num1 = 1;
        the_struct1.num2 = 2;
        return the_struct1;
}

int get_struct() {
        struct the_struct the_struct1 = fun();
        return the_struct1.num1 + 1;
}

// return_struct.c

struct the_struct {

int num1;

int num2;

double num3;

double num4;

int *num_ptr1;

int *num_ptr2;

};

struct the_struct fun() {

struct the_struct the_struct1;

the_struct1.num1 = 1;

the_struct1.num2 = 2;

return the_struct1;

}

int get_struct() {

struct the_struct the_struct1 = fun();

return the_struct1.num1 + 1;

}

优化后的代码可能比较晦涩，64位寄存器数量是32位的一倍，为了简便理解，关闭代码优化，并且转为32位汇编，命令:

bash # gcc -O0 -S -masm=intel -m32 return_struct.c

1	bash # gcc -O0 -S -masm=intel -m32 return_struct.c

结果:

        .file   "return_struct.c"
        .intel_syntax noprefix
        .text
        .globl  _fun
        .def    _fun;   .scl    2;      .type   32;     .endef
_fun:
        push    ebp
        mov     ebp, esp
        sub     esp, 32 ; 为结构体在栈帧中分配32字节内存
        mov     DWORD PTR [ebp-32], 1 ; *(ebp - 32) = 1
        mov     DWORD PTR [ebp-28], 2 ; *(ebp - 28) = 1
        ; ebp指向的位置储存着get_struct()函数的ebp值
        ; ebp+4指向返回地址
        ; ebp+8是get_struct()函数中结构体的指针
        mov     eax, DWORD PTR [ebp+8] ; eax = get_struct()函数中结构体的指针
        mov     edx, DWORD PTR [ebp-32] ; edx是fun()函数中结构体首DWORD的值
        mov     DWORD PTR [eax], edx ; *eax = edx，让get_struct()中的结构体第一个DWORD = edx
        ; 结构体剩余的其余值传值
        mov     edx, DWORD PTR [ebp-28]
        mov     DWORD PTR [eax+4], edx
        mov     edx, DWORD PTR [ebp-24]
        mov     DWORD PTR [eax+8], edx
        mov     edx, DWORD PTR [ebp-20]
        mov     DWORD PTR [eax+12], edx
        mov     edx, DWORD PTR [ebp-16]
        mov     DWORD PTR [eax+16], edx
        mov     edx, DWORD PTR [ebp-12]
        mov     DWORD PTR [eax+20], edx
        mov     edx, DWORD PTR [ebp-8]
        mov     DWORD PTR [eax+24], edx
        mov     edx, DWORD PTR [ebp-4]
        mov     DWORD PTR [eax+28], edx
        mov     eax, DWORD PTR [ebp+8]
        leave
        ret     4
        .globl  _get_struct
        .def    _get_struct;    .scl    2;      .type   32;     .endef
_get_struct:
        push    ebp
        mov     ebp, esp
        sub     esp, 40 ; 分配40字节内存
        lea     eax, [ebp-32] ; eax = ebp - 32，eax是结构体的指针
        mov     DWORD PTR [esp], eax ; *esp储存结构体的指针，即get_struct()函数栈顶是结构体的指针
        call    _fun
        sub     esp, 4
        mov     eax, DWORD PTR [ebp-32] ; (ebp - 32)是结构体的地址
        add     eax, 1
        leave
        ret
        .ident  "GCC: (GNU) 5.3.0"

.file "return_struct.c"

.intel_syntax noprefix

.text

.globl _fun

.def _fun; .scl 2; .type 32; .endef

_fun:

push ebp

mov ebp, esp

sub esp, 32 ; 为结构体在栈帧中分配32字节内存

mov DWORD PTR [ebp-32], 1 ; *(ebp - 32) = 1

mov DWORD PTR [ebp-28], 2 ; *(ebp - 28) = 1

; ebp指向的位置储存着get_struct()函数的ebp值

; ebp+4指向返回地址

; ebp+8是get_struct()函数中结构体的指针

mov eax, DWORD PTR [ebp+8] ; eax = get_struct()函数中结构体的指针

mov edx, DWORD PTR [ebp-32] ; edx是fun()函数中结构体首DWORD的值

mov DWORD PTR [eax], edx ; *eax = edx，让get_struct()中的结构体第一个DWORD = edx

; 结构体剩余的其余值传值

mov edx, DWORD PTR [ebp-28]

mov DWORD PTR [eax+4], edx

mov edx, DWORD PTR [ebp-24]

mov DWORD PTR [eax+8], edx

mov edx, DWORD PTR [ebp-20]

mov DWORD PTR [eax+12], edx

mov edx, DWORD PTR [ebp-16]

mov DWORD PTR [eax+16], edx

mov edx, DWORD PTR [ebp-12]

mov DWORD PTR [eax+20], edx

mov edx, DWORD PTR [ebp-8]

mov DWORD PTR [eax+24], edx

mov edx, DWORD PTR [ebp-4]

mov DWORD PTR [eax+28], edx

mov eax, DWORD PTR [ebp+8]

leave

ret 4

.globl _get_struct

.def _get_struct; .scl 2; .type 32; .endef

_get_struct:

push ebp

mov ebp, esp

sub esp, 40 ; 分配40字节内存

lea eax, [ebp-32] ; eax = ebp - 32，eax是结构体的指针

mov DWORD PTR [esp], eax ; *esp储存结构体的指针，即get_struct()函数栈顶是结构体的指针

call _fun

sub esp, 4

mov eax, DWORD PTR [ebp-32] ; (ebp - 32)是结构体的地址

add eax, 1

leave

ret

.ident "GCC: (GNU) 5.3.0"

汇编代码已写上注释。

在get_struct()函数中，调用fun()之前，会首先把get_struct()函数中要接收返回值的地址压入栈中。

在fun()中，要返回值时，直接从get_struct()的栈帧取得保存结构体值的地址，直接对get_struct()的栈帧进行操作。

总的来说，一个函数要返回一个结构体，则从调用者函数的栈帧中取得接收结构体的地址（被赋值结构体的指针），直接对调用者函数的栈帧进行修改。

关于Visual Studio C LANG下pow()函数的重载

当初看到Visual Studio 2010的这个提示，我真当VS实现了C LANG的函数重载。

今天即兴尝试VS下C LANG的函数重载，虽然IDE没报语法错误，但编译器编译时会报错。无奈之下只好打开长长的math.h一探究竟。

通过全文搜索很容易找到math.h声明的pow()原型：

double  __cdecl pow(_In_ double _X, _In_ double _Y);
inline double __CRTDECL pow(_In_ double _X, _In_ int _Y)
        {return (_Pow_int(_X, _Y)); }
inline float __CRTDECL pow(_In_ float _X, _In_ float _Y)
        {return (powf(_X, _Y)); }
inline float __CRTDECL pow(_In_ float _X, _In_ int _Y)
        {return (_Pow_int(_X, _Y)); }
inline long double __CRTDECL pow(_In_ long double _X, _In_ long double _Y)
        {return (powl(_X, _Y)); }
inline long double __CRTDECL pow(_In_ long double _X, _In_ int _Y)
        {return (_Pow_int(_X, _Y)); }

double __cdecl pow(_In_ double _X, _In_ double _Y);

inline double __CRTDECL pow(_In_ double _X, _In_ int _Y)

{return (_Pow_int(_X, _Y)); }

inline float __CRTDECL pow(_In_ float _X, _In_ float _Y)

{return (powf(_X, _Y)); }

inline float __CRTDECL pow(_In_ float _X, _In_ int _Y)

{return (_Pow_int(_X, _Y)); }

inline long double __CRTDECL pow(_In_ long double _X, _In_ long double _Y)

{return (powl(_X, _Y)); }

inline long double __CRTDECL pow(_In_ long double _X, _In_ int _Y)

{return (_Pow_int(_X, _Y)); }

声明的这些原型一眼看上去没什么问题，挺正常的重载方式。不过math.h内容有点多，不细心点还是看不出来，实际上pow()的重载使用了条件编译：

...
#ifdef  __cplusplus
extern "C" {
#endif
...
double  __cdecl pow(_In_ double _X, _In_ double _Y);
...
#ifdef  __cplusplus
}
extern "C++" {
...
inline double __CRTDECL pow(_In_ double _X, _In_ int _Y)
        {return (_Pow_int(_X, _Y)); }
inline float __CRTDECL pow(_In_ float _X, _In_ float _Y)
        {return (powf(_X, _Y)); }
inline float __CRTDECL pow(_In_ float _X, _In_ int _Y)
        {return (_Pow_int(_X, _Y)); }
inline long double __CRTDECL pow(_In_ long double _X, _In_ long double _Y)
        {return (powl(_X, _Y)); }
inline long double __CRTDECL pow(_In_ long double _X, _In_ int _Y)
        {return (_Pow_int(_X, _Y)); }
...
}
#endif

...

#ifdef __cplusplus

extern "C" {

#endif

...

double __cdecl pow(_In_ double _X, _In_ double _Y);

...

#ifdef __cplusplus

}

extern "C++" {

...

inline double __CRTDECL pow(_In_ double _X, _In_ int _Y)

{return (_Pow_int(_X, _Y)); }

inline float __CRTDECL pow(_In_ float _X, _In_ float _Y)

{return (powf(_X, _Y)); }

inline float __CRTDECL pow(_In_ float _X, _In_ int _Y)

{return (_Pow_int(_X, _Y)); }

inline long double __CRTDECL pow(_In_ long double _X, _In_ long double _Y)

{return (powl(_X, _Y)); }

inline long double __CRTDECL pow(_In_ long double _X, _In_ int _Y)

{return (_Pow_int(_X, _Y)); }

...

}

#endif

查找了一下资料，得知”__cplusplus”是CPP下才有的预定义宏，毕竟”C Plus Plus”……

也就是说，编译C LANG的情况下，仅有这个原型起作用:

double  __cdecl pow(_In_ double _X, _In_ double _Y);

1	double __cdecl pow(_In_ double _X, _In_ double _Y);

其他的重载用的原型根本就不会被编译。

这下结论明确，C LANG根本没有函数重载，那就更加别谈对pow()的重载了，只是IDE对条件编译的检测不完善，才有本文首图的那种提示。

最后自己弄一个伪函数重载玩玩:

#include <stdio.h>

#ifdef  __cplusplus
extern "C" {
#endif
float fun(double n1, double n2)
{
	return (float) (n1 + n2);
}
#ifdef  __cplusplus
}
extern "C++" {
int fun(float n1, int n2)
{
	return (int) (n1 + n2);
}

double fun(double n1, int n2)
{
	return n1 + n2;
}
}
#endif


int main(int argc, char **argv)
{
	printf("%lf\n", fun(1, 2));
	return 0;
}

#include <stdio.h>

#ifdef __cplusplus

extern "C" {

#endif

float fun(double n1, double n2)

{

return (float) (n1 + n2);

}

#ifdef __cplusplus

}

extern "C++" {

int fun(float n1, int n2)

{

return (int) (n1 + n2);

}

double fun(double n1, int n2)

{

return n1 + n2;

}

#endif

int main(int argc, char **argv)

{

printf("%lf\n", fun(1, 2));

return 0;

}

为何C语言函数可以返回struct

struct可由多个数据类型构成，初步看起来应该类似数组，变量本身是一个指向首字节的指针，无法直接通过此指针赋值struct，在函数中声明为自动变量时，也无法返回此指针所指向的值。

但事实上就并非如此，struct之间可以直接赋值，使用指针指向其地址时需要使用”&”，函数中声明为自动变量时可以直接return其值。

那struct变量本身到底是何？

写了这样一个东西，运行后瞬间明白：

#include <stdio.h>
#include <string.h>

struct my_struct {
    unsigned char ch1;
    unsigned char ch2;
    unsigned char ch3;
    unsigned char ch4;
};

int main()
{
    struct my_struct struct1;
    memset(&struct1, 0, sizeof(struct my_struct));
    printf("%u\n", struct1);
    struct1.ch1 = 0xFF;
    printf("%u\n", struct1);
    struct1.ch2 = 0xFF;
    printf("%u\n", struct1);
    struct1.ch3 = 0xFF;
    printf("%u\n", struct1);
    struct1.ch4 = 0xFF;
    printf("%u\n", struct1);
    return 0;
}

#include <stdio.h>

#include <string.h>

struct my_struct {

unsigned char ch1;

unsigned char ch2;

unsigned char ch3;

unsigned char ch4;

};

int main()

{

struct my_struct struct1;

memset(&struct1, 0, sizeof(struct my_struct));

printf("%u\n", struct1);

struct1.ch1 = 0xFF;

printf("%u\n", struct1);

struct1.ch2 = 0xFF;

printf("%u\n", struct1);

struct1.ch3 = 0xFF;

printf("%u\n", struct1);

struct1.ch4 = 0xFF;

printf("%u\n", struct1);

return 0;

}

struct变量就和基本类型，int, char等一样，直接指向其值，而且struct有多少字节，那个值就有多少字节。

也就是说，我们声明一个struct类型时，就是的的确确等于声明了一个确定大小的类型，就和int, char等基本类型一致。

既然是指向值，有确定大小，而且不是地址，那么就可以解释为何可以直接赋值以及可以被函数return了。

返回数组：

#include <stdio.h>

struct size_struct {
    int num_array[100];
};

struct size_struct return_a_array();

int main(void) {
    struct size_struct my_struct;
    int * const my_array = &my_struct;
    my_struct = return_a_array();
    for (int i = 0; i < 100; i++)
        printf("%d\n", my_array[i]);
    return 0;
}

struct size_struct return_a_array() {
    struct size_struct my_struct;
    int * const my_array = &my_struct;
    for (int i = 0; i < 100; i++)
        my_array[i] = i;
    return my_struct;
}

#include <stdio.h>

struct size_struct {

int num_array[100];

};

struct size_struct return_a_array();

int main(void) {

struct size_struct my_struct;

int * const my_array = &my_struct;

my_struct = return_a_array();

for (int i = 0; i < 100; i++)

printf("%d\n", my_array[i]);

return 0;

}

struct size_struct return_a_array() {

struct size_struct my_struct;

int * const my_array = &my_struct;

for (int i = 0; i < 100; i++)

my_array[i] = i;

return my_struct;

}

C float类型精确到N位小数的值的比较

博客更换域名后的第一篇文章。

本周，程序设计基础老师布置了一个上机作业，其中一项是一次生成两个零到九的随机数与加减乘除中的一个运算符号，输出两个数的运算式子，让用户输入运算结果，再把用户输入的值与程序运算的结果比较，从而判断用户运算的结果是否正确。

看到这项作业，我担心遇到无理数的时候如何处理，不可能让人也算到那么多位小数吧……

奇葩的是，老师的给我们的演示截图中恰好没有出现除不尽的情况，不知道是不是特意的？不然我就可以看看老师是偷懒用了整数型还是有高明的算法用浮点型了。

首先想到的是：以数学解决问题

根据多年的人工计算经验，一般都是保留两位小数，因此要求用户输入的数字精确到二位小数即可。

于是手工推导出了判断精确到二位小数后数值正确的条件（字写得不好看，就不拍图了）：

-0.005<用户输入值-计算机计算的结果<=0.005

不过缺点也很明显的，你无法阻止用户输入有小于0.005的误差的值。

整数还好解决，强制转换为整数型再相减，结果为0即可判断出用户输入的值是否有误差。

如果是0.550这种，用户输入了0.5519999999999999999999999999……，根据上述推导的判断条件，成立，回答正确。

如何判断用户输入的小数是否多于二位？

于是换了个方向，如何处理计算机的计算结果为保留二位小数后的数值？因为这样的话，就不需要“-0.005<用户输入值-计算机计算的结果<=0.005”这个判断条件了。

如果要手工把浮点型转换为字符串，太麻烦了，假如尾数是1.111，那么总和是1+0.5+0.25+0.125，要实现小数加法……

还是放弃数学方法好了……

平时都用printf()，可以很方便的把各种类型数据格式化为字符串输出，且“.x”修饰符会自动为你四舍五入，既然如此，我可以把格式化输出和格式化输入工作交给C的stdio库了。

printf()是输出到标准输出的，不能用这个，平时用Linux，习惯了数据流重定向，于是想fprintf到stdin，然后scanf stdin，不过很可惜stdin是READ ONLY的。

还有sprintf()与sscanf()，这两个函数直接操作内存，输出和读入的都为字符类型。

到这里，方向明确了，声明一个变量，作为buffer，然后使用sprintf()格式化输出到buffer，再用sscanf()从buffer格式化读入。

最终的代码如下：

#include <stdio.h>

int main ()
{
    char float_string[20]; // 20字节的buffer
    double num = 5.465/8.69625, user_input; // 声明两个双精度浮点型变量
    printf("内部数值: %.9lf\n请输入内部数值保留二位小数后的数值(四舍五入): ", num);
    scanf("%lf", &user_input); // 读入用户输入的值
    sprintf(float_string,"%.2lf", num); // 把内部值以文本形式格式化为两位小数输出到buffer，这里格式化后自动四舍五入
    sscanf(float_string, "%lf", &num); // 以文本形式，从buffer中读入内容，格式化为双精度浮点型
    printf("输入%s\n", num == user_input ? "正确" : "错误");
    return 0;
}

#include <stdio.h>

int main ()

{

char float_string[20]; // 20字节的buffer

double num = 5.465/8.69625, user_input; // 声明两个双精度浮点型变量

printf("内部数值: %.9lf\n请输入内部数值保留二位小数后的数值(四舍五入): ", num);

scanf("%lf", &user_input); // 读入用户输入的值

sprintf(float_string,"%.2lf", num); // 把内部值以文本形式格式化为两位小数输出到buffer，这里格式化后自动四舍五入

sscanf(float_string, "%lf", &num); // 以文本形式，从buffer中读入内容，格式化为双精度浮点型

printf("输入%s\n", num == user_input ? "正确" : "错误");

return 0;

}

这里还有一个更简单的方法：

#include <stdio.h>

int main ()
{
    double num = 5.465/8.69625, user_input; // 声明两个双精度浮点型变量
    int num_i; // 声明一个整数型变量
    printf("内部数值: %.9lf\n请输入内部数值保留二位小数后的数值(四舍五入): ", num);
    scanf("%lf", &user_input); // 读入用户输入的值
    num_i = num * 1000; // 这样就能取到前三位小数，以整数型储存
    num_i += num_i % 10 >= 5 ? 10 : 0; // 对十取余，取得第三位小数，根据第三位小数是否大于等于5而决定是否需要进一
    num_i /= 10; // 除十可以去掉第三位小数
    num = num_i / 100.; // 这样可以还原为双精度浮点型，好处是不需要改动用户输入的数字，因为一旦把用户输入的数字乘一百，就有可能把用户输入与正确值的误差小于0.01的数当成正确的
    printf("输入%s\n", num == user_input ? "正确" : "错误");
    return 0;
}

#include <stdio.h>

int main ()

{

double num = 5.465/8.69625, user_input; // 声明两个双精度浮点型变量

int num_i; // 声明一个整数型变量

printf("内部数值: %.9lf\n请输入内部数值保留二位小数后的数值(四舍五入): ", num);

scanf("%lf", &user_input); // 读入用户输入的值

num_i = num * 1000; // 这样就能取到前三位小数，以整数型储存

num_i += num_i % 10 >= 5 ? 10 : 0; // 对十取余，取得第三位小数，根据第三位小数是否大于等于5而决定是否需要进一

num_i /= 10; // 除十可以去掉第三位小数

num = num_i / 100.; // 这样可以还原为双精度浮点型，好处是不需要改动用户输入的数字，因为一旦把用户输入的数字乘一百，就有可能把用户输入与正确值的误差小于0.01的数当成正确的

printf("输入%s\n", num == user_input ? "正确" : "错误");

return 0;

}