相关疑难解决方法(0)

我可以用c ++/g ++做到这一点:

struct vec3 { 
    union {
        struct {
            float x, y, z;
        }; 
        float xyz[3];
    }; 
};

然后,

vec3 v;
assert(&v.xyz[0] == &v.x);
assert(&v.xyz[1] == &v.y);
assert(&v.xyz[2] == &v.z);

将工作.

如何使用gcc在c中执行此操作？我有

typedef struct {
    union {
        struct {
            float x, y, z;
        };
        float xyz[3];
    };
} Vector3;

但我特别是周围都有错误

line 5: warning: declaration does not declare anything
line 7: warning: declaration does not declare anything

在K&R第6章中,声明如下:

struct{
    int len;
    char *str;
} *p;

我无法理解这个指针p指向哪个结构,如果这样的指针定义甚至是有效的,因为在书中给出的所有其他示例和我看到的其他示例中,在定义指向结构的指针时,名称需要提及结构,即定义的类型.例如,

struct example{
    int a;
    ...
}s1;

然后,

struct example *ptr = &s1;

所以,提到ptr指向一个类型结构示例而不仅仅是struct.

此外,特别感兴趣的是:

*p-> str获取任何str点;*p-> str ++在访问它指向的任何内容后递增str(就像*s ++);

我无法首先遵循p是什么,因此,也不是增量和解除引用.

这里发生了什么？

提前致谢!

PS我是新来的,所以对这个问题的格式的任何反馈也将不胜感激.

我必须构建一个嵌套结构来存储一些人的某些基本信息(姓名,年龄,地址).所以我创建了一个名为"info"的结构,并保存地址,我在"info"中创建了另一个嵌套结构,名为"address".但每当我提示使用for循环存储值时,我都会收到错误.这里有什么问题,我该如何解决？

[错误]'struct Info'没有名为'address'的成员
[Warning]声明没有声明任何内容[默认启用]

#include <stdio.h>

int main(){

    struct Info{
        char name[30];
        int age;
        struct address{
            char area_name[39];
            int house_no;
            char district[39];
        };
    };

    struct Info Person[10];

    int i;
    for(i=0;i<10;i++){

        printf("enter info of person no %d\n",i);
        printf("enter name\n");
        scanf("%s",&Person[i].name);
        printf("enter age\n");
        scanf("%d",&Person[i].age);
        printf("enter address :\n");
        printf("enter area name :\n");
        scanf("%s",&Person[i].address.area_name);
        printf("enter house no : \n");
        scanf("%d",&Person[i].address.house_no);
        printf("enter district : \n");
        scanf("%s",&Person[i].address.district);
    }
}

我发现一个代码实现为下面显示的类似演示..

struct st
{
 int a;
 struct
 {
 int b;
 };
};

6.58内未命名的struct/union字段structs/unions

在允许的情况下ISO C11.

但它有什么好处呢？

因为无论如何我可以以相同的方式访问数据成员

int main()
{
 struct st s;
 s.a=11;
 s.b=22;
 return 0;
}

在gcc 4.5.2上编译,用

gcc -Wall demo.c -o demo 

并没有错误,

如果有人回答我的问题,请不要告诉我使用C++.

所以,我在C中创建了一个使用面向对象方法的小型库.我选择在C中使用两种主要的继承方法中较不常见的方法:将基类型的成员复制到派生类型的开头.像这样的东西:

struct base {
  int a;
  int b;
  char c;
};

struct derived {
  int a;
  int b;
  char c;
  unsigned int d;
  void (*virtual_method)(int, char);
};

这种方法不如另一种方法(基类型的实例作为派生类型的第一个成员)受欢迎,因为

1. 从技术上讲,没有标准保证基础和派生结构的第一个共同成员将具有相同的抵消.但是,除了其中一个结构被打包而另一个结构没有被打包的情况之外,它们将在大多数(如果不是全部)已知编译器上具有相同的偏移量.
2. 这种方法最严重的缺陷:它违反了严格的别名.将指向派生结构的指针强制转换为其基类型然后解除引用指针在技术上是未定义的行为.

但是,与其他方法相比,它也有其优点:

1. 更少详细:访问已继承的派生结构的成员与访问尚未继承的结构相同,而不是转换为基类型,然后访问所需的成员;
2. 这实际上是真正的继承而不是构成 ;
3. 虽然可能需要一些预处理器滥用,但它与其他方法一样容易实现;
4. 我们可以得到一个实际多重继承的半生不熟的形式,我们可以从几个基类型继承,但只能转换为其中一个.

我一直在寻找使我的库编译和使用强制执行严格别名(如gcc)的编译器正确工作的可能性,而无需用户手动关闭它.以下是我研究过的可能性:

1. 工会.遗憾的是,由于以下几个原因,这些是禁忌:

   1. 详细程度回归!要遵循通过联合访问2个结构的第一个共同成员的标准规则,必须(从C99开始)明确使用联合来访问第一个共同成员.我们需要特殊的语法来访问联合中每种类型的成员!
   2. 空间.考虑一个继承层次结构.我们有一个类型,我们希望能够从每个派生类型转换为.我们希望为每种类型做到这一点.我看到的唯一可行的联合使用解决方案是整个层次结构的并集,它必须用于将派生类型的实例转换为基类型.它必须与整个层次结构中派生类型最多的一样大......

2. 使用memcpy而不是直接解除引用(如此处).这看起来是个不错的解决方案.但是,函数调用会产生开销,是的,再一次,冗长.据我所知,memcpy也可以通过将指向结构的指针强制转换为指针char然后解除引用来手动完成,如下所示:(member_type)(*((char*)(&struct_pointer->member))) = new_value;Gah,再次详述.好吧,这可以用宏包裹.但是,如果我们将指针转换为指向不兼容类型的指针,然后将其转换为char*并取消引用它,那么它仍然可以工作吗？像这样:(member_type)(*((char*)(&((struct incompatible_type*)struct_pointer)->member))) = new_value;

3. 声明我们将要转换为的所有类型实例 …

GCC 有一个标志-fms-extensions。

这个标志究竟有什么作用？为什么它有时默认开启，为什么它存在？

我刚看到一段代码片段: -

struct a {
    int mem1;
    char mem2;

    struct {
        int inner_mem1;
        int inner_mem2;
    };
};

我发现代码片段使用内部struct的成员直接使用外部struct的变量名!例如:

struct a *avar;
....
avar->inner_mem1

这是合法的,代码编译然而且工作正常!以这种方式使用它的目的是什么？任何具体情况？

请让我知道你的想法.

为什么在Linux中很多结构使用____cacheline_aligned_in_smp宏？在访问结构时是否有助于提高性能.如果是,那怎么样？

请考虑从http://www.haskell.org上的教程中获取的以下定义:

data Tree a                = Leaf a | Branch (Tree a) (Tree a) 
fringe                     :: Tree a -> [a]
fringe (Leaf x)            =  [x]
fringe (Branch left right) =  fringe left ++ fringe right

我不清楚函数条纹执行时在运行时会发生什么.

在编译表达式时fringe left,(1)编译器是否已经知道left树是a Branch还是a Leaf- 即它只对静态已知的树进行操作 - 或者(2)它是否发出一些if/ switch类似条件来检查left树是否为a Leaf或者一个Branch

如果它是后面的ie(2)那么,为什么这应该比等效的C函数更加类型安全,它基本上看起来就像上面那样,只是只有一种类型浮动(指向节点的指针).

我有以下内容：

#include <stdio.h>

typedef union u_data
{
        struct
        {
                int a;
                int b;
                int c;
        };
                int elem[3];
}       my_data;

int     main(void)
{
        my_data data;

        data.a = 3;
        data.b = 5;
        data.c = -3;
        printf("%d, %d, %d\n", data.elem[0], data.elem[1], data.elem[2]);
}

它按照我的预期输出：3, 5, -3

但是我知道结构中可以有填充，所以这是否意味着结构中的元素可能并不总是与数组对齐？