linux c奇淫技巧v1

最新推荐文章于 2020-04-23 10:50:04 发布

侵蚀昨天

最新推荐文章于 2020-04-23 10:50:04 发布

阅读量397

点赞数

分类专栏： linux c/c++ 文章标签： c linux

本文链接：https://blog.csdn.net/q2519008/article/details/85701578

版权

linux 同时被 2 个专栏收录

62 篇文章 5 订阅

订阅专栏

c/c++

14 篇文章 2 订阅

订阅专栏

数组相关

零长数组:

struct b

{
    int a;
    int b[0]; //不占空间
}
/*
1、动态分配可变长度的数组
2、方便释放，原地及数据
3、提高访问速度
*/

为什么不用指针代替零长数组？

struct buffer1{
    int len;
    int a[0];
};
struct buffer2{
    int len;
    int *a;
};
int main(void)
{
    printf("buffer1: %d\n", sizeof(struct buffer1));
    printf("buffer2: %d\n", sizeof(struct buffer2));
    return 0;
}

结果为：

buffer1：4

buffer2：8

1、需要单独为这个指针分配空间，这个指针指向的是另外一片空间

2、造成结构体冗余，使用不方便

数组指定初始化：

int a[100] = {[1]=1, [50] = 1}； //a[1]=1，a[50] =1

int a[100] = {[10 ... 30] = 1, [60 ... 70] = 1}；//范围初始化

同样的case语句中也可以使用：

case 1:

         break;

case 2 ... 5:

         break;

指定初始化结构体成员变量：

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

int main(void)
{
    struct student stu1={ "wit",20 };
    printf("%s:%d\n",stu1.name,stu1.age);

    struct student stu2=
    {
        .name = "wanglitao",
        .age  = 28
    };
    printf("%s:%d\n",stu2.name,stu2.age);

    return 0;
}

语句表达式：

({ 表达式1; 表达式2; 表达式3; })

语句表达式的值为内嵌语句中最后一个表达式的值，即表达式3的值

int main(void)
{
    int sum = 0;
    sum = 
    ({
        int s = 0;
        for( int i = 0; i < 10; i++)
            s = s + i;
            s;
    });
    printf("sum = %d\n",sum);
    return 0;
}

/*
语句表达式的值等于最后一个表达式的值，所以在 for 循环的后面，我们要添加一个 s
*/

我们一般多在宏定义中使用语句表达式

举个例子：定义一个宏，求两个数的最大值

很常见的一个宏，那么究竟有多少门道？？

不及格：
#define  MAX(x,y)  x > y ? x : y  //运算符优先级导致结果不符合，例如max(1+1,2)

及格：
#define MAX(x,y) (x) > (y) ? (x) : (y)

/*
解决了上面的问题，还是存在漏洞，例如：
#define MAX(x,y) (x) > (y) ? (x) : (y)
int main(void)
{
    printf("max=%d",3 + MAX(1,2));
    return 0;
}
展开为：
3 + (1) > (2) ? (1) : (2);  还是运算符优先级问题，错误
*/

合格：现在一般的写法也是这样，但是还是有问题
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void)
{
    int i = 2;
    int j = 6;
    printf("max=%d",MAX(i++,j++));
    return 0;
}

/*
在程序中，我们定义两个变量 i 和 j，然后比较两个变量的大小，并作自增运算。
实际运行结果发现 max = 7，而不是预期结果 max = 6。这是因为变量 i 和 j 在宏展开后，
做了两次自增运算，导致打印出 i 的值为7
*/

良好：使用了语句表达式
#define MAX(x,y)({     \
    int _x = x;        \
    int _y = y;        \
    _x > _y ? _x : _y; \
})

int main(void)
{
    int i = 2;
    int j = 6;
    printf("max=%d",MAX(i++,j++));
    return 0;
}
/*
上面的宏定义的是int，还需要优化
*/

优秀：能这样写已经很棒了，但是还能不能继续优化？
#define MAX(type, x, y)({     \
    type _x = x;        \
    type _y = y;        \
    _x > _y ? _x : _y; \
})

int main(void)
{
    int i = 2;
    int j = 6;
    printf("max=%d\n",MAX(int,i++,j++));
    printf("max=%f\n",MAX(float,3.14,3.15));
    return 0;
}

完美：

完美：使用了typeof，避免多传递参数
#define MAX(x,y)({     \
    typeof(x) _x = x;        \
    typeof(x) _y = y;        \
    _x > _y ? _x : _y; \
})

int main(void)
{
    int i = 2;
    int j = 6;
    printf("max: %d\n", MAX(i, j));
    printf("max: %f\n", MAX(3.14, 3.15));
    return 0;
}

那么在linux内核中利用typeof特性还有一个写法？

#define max(x, y) ({                \
    typeof(x) _max1 = (x);          \
    typeof(y) _max2 = (y);          \
    (void) (&_max1 == &_max2);      \
    _max1 > _max2 ? _max1 : _max2; })


/*

(void) (&_max1 == &_max2);
这一句很有意思：看起来是一句废话，其实用得很巧妙！它主要是用来检测宏的两个参数 x 和 y 的数据类型
是否相同。如果不相同，编译器会给一个警告信息，提醒程序开发人员：
warning：comparison of distinct pointer types lacks a cast

让我们分析一下，它是怎么实现的：语句 &_max1 == &_max2 用来判断两个变量 _max1 和 _max2 的地址是
否相等，即比较两个指针是否相等。&_max1 和 &_max2分别表示两个不同变量的地址，怎么可能相等呢！既然
大家都知道，内存中两个不同的变量地址肯定不相等，那为什么还要在此多此一举呢？妙就妙在，当两个变量
类型不相同时，对应的地址，即指针类型也不相同。比如一个 int 型变量，一个 char 变量，对应的指针类型，
分别为 char * 和 int *，而两个指针比较，它们必须是同种类型的指针，否则编译器会有警告信息。所以，
通过这种“曲线救国”的方式，这行程序语句就实现了这样一个功能：当宏的两个参数类型不相同时，编译器会及
时给我们一个警告信息，提醒开发者。
*/