Fatal编程技术网
  • import/
  • Import 协议缓冲区根据另一条导入的消息导入消息

Import 协议缓冲区根据另一条导入的消息导入消息

import protocol-buffers

Import 协议缓冲区根据另一条导入的消息导入消息,import,protocol-buffers,Import,Protocol Buffers,关于进口声明，谷歌表示： 您可以通过导入其他.proto文件中的定义来使用它们。要导入另一个.proto的定义，请在文件顶部添加一条导入语句。 默认情况下，只能使用直接导入的.proto文件中的定义 …听起来不错，但那又如何： 1.proto： message M1{ required string foo = 1; } 2.proto： import "1.proto"; message M2{ required M1 m_1 = 1; } 3.proto： import "

关于进口声明，谷歌表示：

您可以通过导入其他.proto文件中的定义来使用它们。要导入另一个.proto的定义，请在文件顶部添加一条导入语句。 默认情况下，只能使用直接导入的.proto文件中的定义

…听起来不错，但那又如何：

1.proto：

message M1{
   required string foo = 1;
}
2.proto：

import "1.proto";
message M2{
    required M1 m_1 = 1;
}
3.proto：

import "2.proto";
message M3{
    required M2 m_2 = 1;
}
因此，在解析3.proto时，M1不应该被访问，因为1.proto不是从2.proto公开导入的。 但是，M2应该是，因为它是直接从3.proto导入的

那么M2.m_1呢？编译器应该如何生成类？

文档的意思是，如果要在文件中引用
M1
，则必须导入
1.proto
，如果要在文件中引用
M2
，则必须导入
2.proto
。您不需要显式导入隐式/可传递依赖项。使用
M2
而不导入
1.proto
是非常好的

编译器实际上遵循可传递导入并读取所有三个文件，以便为
3.proto
生成代码。另外，在C++中，<>代码> 3。PB2.H./C> >代码> >包含“2。PB2.H”< /代码>，而代码<>代码包括“1。PB2.H”< /代码>。该规则只是一个语法规则

为什么有这个规定？那么，考虑一下，如果你可以直接在<代码> 3中直接使用<代码> M1 < /代码> .PROTUT/COD>不显式导入<代码> 1。原<代码>，因为你导入了代码> 2。现在考虑，如果以后，代码< > 2的维护者。PROTO to /COD>决定删除字段<代码> MY1。现在
2.proto
不使用
M1
，因此维护人员决定删除导入
1.proto
。但是现在
3.proto
被破坏了，因为它依赖于
2.proto
导入
1.proto

<>这是C++常见的问题。我不想在Protobufs中遇到同样的问题，所以我制定了规则，您必须显式导入所有文件，声明您在自己的文件中显式使用的类型。

文档的意思是，如果您想在文件中引用
M1
，则必须导入
1.proto
，如果要在文件中引用
M2
，则必须导入
2.proto
。您不需要显式导入隐式/可传递依赖项。使用
M2
而不导入
1.proto
是非常好的

编译器实际上遵循可传递导入并读取所有三个文件，以便为
3.proto
生成代码。另外，在C++中，<>代码> 3。PB2.H./C> >代码> >包含“2。PB2.H”< /代码>，而代码<>代码包括“1。PB2.H”< /代码>。该规则只是一个语法规则

为什么有这个规定？那么，考虑一下，如果你可以直接在<代码> 3中直接使用<代码> M1 < /代码> .PROTUT/COD>不显式导入<代码> 1。原<代码>，因为你导入了代码> 2。现在考虑，如果以后，代码< > 2的维护者。PROTO to /COD>决定删除字段<代码> MY1。现在
2.proto
不使用
M1
，因此维护人员决定删除导入
1.proto
。但是现在
3.proto
被破坏了，因为它依赖于
2.proto
导入
1.proto

<>这是C++常见的问题。我不想在Protobufs中遇到同样的问题，所以我制定了规则，您必须显式导入所有文件，声明您在自己的文件中显式使用的类型。

文档的意思是，如果您想在文件中引用
M1
，则必须导入
1.proto
，如果要在文件中引用
M2
，则必须导入
2.proto
。您不需要显式导入隐式/可传递依赖项。使用
M2
而不导入
1.proto
是非常好的

编译器实际上遵循可传递导入并读取所有三个文件，以便为
3.proto
生成代码。另外，在C++中，<>代码> 3。PB2.H./C> >代码> >包含“2。PB2.H”< /代码>，而代码<>代码包括“1。PB2.H”< /代码>。该规则只是一个语法规则

为什么有这个规定？那么，考虑一下，如果你可以直接在<代码> 3中直接使用<代码> M1 < /代码> .PROTUT/COD>不显式导入<代码> 1。原<代码>，因为你导入了代码> 2。现在考虑，如果以后，代码< > 2的维护者。PROTO to /COD>决定删除字段<代码> MY1。现在
2.proto
不使用
M1
，因此维护人员决定删除导入
1.proto
。但是现在
3.proto
被破坏了，因为它依赖于
2.proto
导入
1.proto

<>这是C++常见的问题。我不想在Protobufs中遇到同样的问题，所以我制定了规则，您必须显式导入所有文件，声明您在自己的文件中显式使用的类型。

文档的意思是，如果您想在文件中引用
M1
，则必须导入
1.proto
，如果要在文件中引用
M2
，则必须导入
2.proto
。您不需要显式导入隐式/可传递依赖项。使用
M2
而不导入
1.proto
是非常好的

编译器实际上遵循可传递导入并读取所有三个文件，以便为
3.proto
生成代码。另外，在C++中，<>代码> 3。PB2.H./C> >代码> >包含“2。PB2.H”< /代码>，而代码<>代码包括“1。PB2.H”< /代码>。该规则只是一个语法规则

为什么