标签: struct

所以通常我不会问这样的问题，因为它似乎可能是基于意见的，或者对编码实践发起某种口头战争，但我认为这里可能有一个我不明白的技术原因。

我正在查看 vcpkg（微软正在创建的库打包管理器，是“新”代码）的头文件中的代码，因为阅读代码通常是学习您不知道的东西的好方法。

我注意到的第一件事是使用using而不是typedef。

来自“ https://github.com/microsoft/vcpkg/blob/master/toolsrc/include/vcpkg/parse.h ”的片段

template<class P>
using ParseExpected = ExpectedT<std::unique_ptr<P>, std::unique_ptr<ParseControlErrorInfo>>;

我之前没有亲自使用过using这种方式，答案来自：What is the Difference Between 'typedef' and 'using' in C++11? 。本质上，using是一种新的实现方式，好处是可以使用模板。所以微软有充分的理由使用using而不是typedef.

看着' https://github.com/microsoft/vcpkg/blob/master/toolsrc/include/vcpkg/commands.h '我注意到他们没有使用任何类。相反，它只是其中包含函数等的名称空间。IE：

namespace vcpkg::Commands
{
    namespace BuildExternal
    {
        void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet);
    }
}

我猜测其中的一部分是调用语法看起来本质上就像类中的静态成员函数，因此代码执行相同的操作，但可能通过作为命名空间而不是类来节省一些开销。（如果有人对此也有任何想法，那就太好了。）

现在是这一切的要点。为什么 Microsoft 在其命名空间中使用结构而不是类？

来自“ https://github.com/microsoft/vcpkg/blob/master/toolsrc/include/vcpkg/parse.h ”的片段：

namespace vcpkg::Parse
{
    /* ... Code I'm excluding for brevity ... */

    struct …

我正在尝试将空值添加为结构的默认值。有什么办法可以将 null 添加为默认值吗？

type Values struct {
    FirstValue string `default:"My First Value"`
    SecondValue string `default:nil` // something like that
}

如何在没有显式的情况下迭代结构中的字段并检查它们是否不为空？

我有一个示例结构

type Example struct {
    Foo, Bar string
}

我可以明确检查每个字段是否不是“”，但我不想这样做。有什么简单的方法可以完成我的需要吗？

我有一个如下所示的程序，当我尝试使用指向指针的指针访问结构成员时，它表示表达式必须具有指向类类型的指针。请告诉我如何使用指向指针的指针访问结构对象的数据元素

#include "stdafx.h"
#include<iostream>
struct Node{
    int data;
    Node* next;
};

void addnode(Node** node, int val)
{
    if (node == NULL){
        *node = new Node();
        *node->data = val;

    }
}



int _tmain(int argc, _TCHAR* argv[])
{
    Node* node;
    addnode(&node, 10);
    return 0;
}

我有一个向量存储结构，并通过地址将其传递给函数。我想知道为什么我只能通过编写来访问元素

(*v)[0].value

Run Code Online (Sandbox Code Playgroud)

代替

v[0].value

Run Code Online (Sandbox Code Playgroud)

当我使用结构数组并通过地址将其传递给函数时，我可以简单地写

v[0].value 获取元素的值。欢迎任何解释并提前致谢。

假设我想将不同类型的数据推送到标准库堆栈中。为了简单起见，我只采用两种类型：

• 整数
• foo（类）

为此，我需要以下数据结构：

//generic class
class foo {
  private:
    float x_;
  public:
    foo(float x) : x_(x){};
};
 
//simple enum
enum element_type {
  footype,
  number
};

struct stack_element {
  element_type type_;
  union {
    foo* obj;
    int num;
  } data;
};

然后我需要在结构体中创建一个构造函数以实现类型双关：

//actually this should be if/else statement in this case but on the code problem I have more types
stack_element(element_type type, foo* obj){
  switch(type){
    case footype: 
      this->type_ = type;
      this->data.obj = obj;
    break;
    case number:
      this->type_ = type;
      // Here …

我不明白为什么下面的代码不能编译。

我很困惑为什么 Go 说HistoryReader没有正确实现IReader。HistoryBook实现IBook. 当尝试将 a 添加到 s 的切片时，为什么Read(book Ibook)和不能同时接受？Read(book HistoryBook)HistoryReaderIReader

package main

type IReader interface {
   Read(book IBook)
}

// HistoryReader implements IReader
type HistoryReader struct{}

func (r *HistoryReader) Read(book HistoryBook) {
   // ...
}

type IBook interface{}

// HistoryBook implements IBook
type HistoryBook struct{}

func main() {
   var readerSlice []IReader

   _ = append(readerSlice, &HistoryReader{})
}

package main

type IReader interface {
   Read(book IBook)
}

// …

这是问题的概述（clang 抛出的错误代码）：

标签的 typedef 和 struct def；

typedef struct tag {int tag;} tag;

这工作得很好：

struct tag {int tag;} tag;

而这些 typedef 错误之一：

typedef struct {int tag;} tag;

/*or*/

typedef struct tag {int tag;} tag;

/*and then this following code fails from either of the two 
previous typedefs which the compiler errors about as being 
redeclared as as different kind of symbol. Not allowed to share 
typedef with object id:*/

tag tag;

当指定相同名称的 typedef/tag 时，两个全局变量上的编译器错误：

/*error: redefinition of 'tag' as different …

所以，我在 Rust Book（布朗大学版本）中发现了这段代码：

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let a = area(rect1);
    println!("{} * {} = {}", rect1.width, rect1.height, a);
}

fn area(rectangle: Rectangle) -> u32 {
    rectangle.width * rectangle.height
}

该代码无法编译，因为当我们调用 时，area(rect1)我们移动了Rectangle. 但是Rectanglecontains 类型的字段u32是原始类型，因此实现了Copy特征。那么应该允许编译。我在这里缺少什么？

两种选择都是合法的，但哪一种更好或更“干净”：

假设我们有这样的结构：

typedef struct MyStruct {
int val;
} MyStruct;

第一个选项；直接返回一个结构体：

MyStruct Create()
{
MyStruct a;
a.val = 0;
return a;
}

第二个选项：在堆上创建结构并返回指针：

MyStruct* CreatePtr()
{
MyStruct *a = (MyStruct*)malloc(sizeof(MyStruct));
a->val = 0;
return a;
}

我认为最好的选择取决于结构的大小，但也许它们是更多需要考虑的事情？