我已经重构我的C++类型安全的伪枚举的乌七八糟新的C++ 0x类型安全的枚举,因为他们的方式更具有可读性.无论如何,我在导出的类中使用它们,所以我明确地将它们标记为要导出:
enum class __attribute__((visibility("default"))) MyEnum : unsigned int
{
One = 1,
Two = 2
};
用g ++编译它会产生以下警告:
在已定义类型后忽略类型属性
这看起来很奇怪,因为据我所知,这个警告是为了防止实际的错误,例如:
class __attribute__((visibility("default"))) MyClass { };
class __attribute__((visibility("hidden"))) MyClass;
当然,我显然没有这样做,因为我只在定义中标记了可见性属性,enum class并且我没有在其他任何地方重新定义或声明它(我可以用单个文件复制此错误).
最终,我不能让这些代码实际上导致问题,除了这样的事实,如果我更改一个值并重新编译消费者而不重新编译共享库,则消费者传递新值和共享图书馆不知道如何处理它们(虽然我不希望它首先起作用).
我是不是太迂腐了？这可以安全地忽略吗？我怀疑是这样,但与此同时,有这个错误阻止我编译Werror,这让我感到不舒服.我真的希望看到这个问题消失.
TL; DR:基本上,我正在寻找Java的Scala等价物:
(MyAnnotation) Thing.getClass().getAnnotations()[0]
尽管我可以根据他们的类型愉快地发现注释和查询,但我似乎无法从scala.reflect.runtime.universe.Annotation我的实际类型中获取.
scala> // Declare an annotation (it seems StaticAnnotation means runtime
scala> // retention)
scala> case class MyAnnotation(x: Int, y: String) extends scala.annotation.StaticAnnotation
defined class MyAnnotation
scala> // Make a thing decorated with MyAnnotation
scala> @MyAnnotation(x=5, y="cool") case class Thing()
defined class Thing
scala> // Look at the annotation on the Thing...the runtime clearly
scala> // understands the values on it
scala> val annotation = scala.reflect.runtime.universe.typeOf[Thing].typeSymbol.asClass.annotations(0)
annotation: reflect.runtime.universe.Annotation = MyAnnotation(5, "cool")
scala> // …我有一个 JSON API，它返回一个如下所示的对象：
{
"PrivatePort": 2222,
"PublicPort": 3333,
"Type": "tcp"
}
为了捕捉这一点，我有一个枚举和一个结构：
{
"PrivatePort": 2222,
"PublicPort": 3333,
"Type": "tcp"
}
目前，该 API 仅支持 中列出的三种协议PortType，但我们假设DCCP将来会添加对 的支持。我不希望 API 的客户端仅仅因为他们可能没有查看的配置选项中的未知字符串而开始失败。
为了解决这个问题，我添加了一个Unknown带有的变体String来表示值：
#[derive(Eq, PartialEq, Deserialize, Serialize, Debug)]
#[serde(rename_all = "snake_case")]
pub enum PortType {
Sctp,
Tcp,
Udp,
}
#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "PascalCase")]
pub struct PortMapping {
pub private_port: u16,
pub public_port: u16,
#[serde(rename = "Type")]
pub port_type: PortType,
}
这里的目标是在PortType::Unknown("dccp")传入未知值时最终得到稍微不方便的值。当然，这不会做我想要的开箱即用的 - 传递未知 …
我正在开发一个跨越许多共享库的相当大的项目.我们也非常依赖STL,Boost和我们自己的模板类和函数.许多导出的类包含模板成员,导出的函数包含模板参数.
这是我如何进行库导出的精简示例:
#if defined(_MSC_VER) && defined(_DLL)
// Microsoft
#define EXPORT __declspec(dllexport)
#define IMPORT __declspec(dllimport)
#elif defined(_GCC)
// GCC
#define EXPORT __attribute__((visibility("default")))
#define IMPORT
#else
// do nothing and hope for the best at link time
#define EXPORT
#define IMPORT
#endif
#ifdef _CORE_COMPILATION
#define PUBLIC_CORE EXPORT
#define EXTERNAL_CORE
#else
#define PUBLIC_CORE IMPORT
#define EXTERNAL_CORE extern
#endif
#include <deque>
// force exporting of templates
EXTERNAL_CORE template class PUBLIC_CORE std::allocator<int>;
EXTERNAL_CORE template class PUBLIC_CORE std::deque<int, std::allocator<int> >;
class PUBLIC_CORE MyObject
{
private:
std::deque<int> …我正在尝试编写一个函数,它使用参数包和一些标准匹配规则来获取另一个函数.举个例子:
template <typename... TListElems, typename... TVectorElems>
void goal(void (*fn)(std::list<TListElems>..., std::vector<TVectorElems>...));
为了消除歧义TListElems和TVectorElems,我增加了一些std::tuple<T...>*使主叫方可以明确的:
template <typename... TListElems, typename... TVectorElems>
void foo(std::tuple<TListElems...>*,
std::tuple<TVectorElems...>*,
void (*)(std::list<TListElems>..., std::vector<TVectorElems>...))
{
// blah blah blah
}
void bar(std::list<int>, std::list<unsigned>, std::vector<float>, std::vector<double>)
{
// blah blah blah
}
int main()
{
foo((std::tuple<int, unsigned>*) nullptr,
(std::tuple<float, double>*) nullptr,
&bar);
}
Clang愉快地以我期望的方式编译它,而g ++(7.2.1)给出了编译错误:
matching.cpp: In function ‘int main()’:
matching.cpp:20:13: error: no matching function for call to ‘foo(std::tuple<int, unsigned int>*, std::tuple<float, double>*, void (*)(std::list<int>, std::list<unsigned int>, …我正在尝试设置我的 Mercurial 存储库系统以使用多个子存储库。我基本上按照这些说明使用 Mercurial 客户端 v1.5 设置客户端存储库，并且我正在使用HgWebDir来托管我的多个项目。
我有一个具有以下结构的 HgWebDir：
http://myserver/hg
|-- fooproj
|-- mylib
. .mylib使用的公共模板库的一些集合在哪里fooproj？的结构fooproj看起来像这样：
fooproj
|-- doc/
| `-- readme
|-- src/
| `-- main.cpp
|-- .hgignore
|-- .hgsub
`-- .hgsubstate
而.hgsub看起来像：
src/mylib = http://myserver/hg/mylib
根据我对文档的解释，这应该有效：
第一个“嵌套”是我们工作目录中的路径，第二个是要从中提取的 URL 或路径。
此外，mylib项目目录结构如下所示：
mylib
|-- .hg
| |-- 00changelog.i
| |-- dirstate
| |-- requires
| |-- store
| | |-- 00changelog.i
| | |-- 00manifest.i
| …如何抑制类型的自动初始化和销毁？虽然T buffer[100]自动初始化所有元素buffer并在它们超出范围时销毁它们是很棒的,但这不是我想要的行为.
#include <iostream>
static int created = 0,
destroyed = 0;
struct S
{
S()
{
++created;
}
~S()
{
++destroyed;
}
};
template <typename T, size_t KCount>
class fixed_vector
{
private:
T m_buffer[KCount];
public:
fixed_vector()
{
// some way to suppress the automatic initialization of m_buffer
}
~fixed_vector()
{
// some way to suppress the automatic destruction of m_buffer
}
};
int main()
{
{
fixed_vector<S, 100> arr;
}
std::cout << "Created:\t" << created …使用新函数声明符语法时decltype,如何访问成员？似乎this无法访问:
template <typename Func>
struct context_binder
{
public:
context_binder(const Func& func) :
func(func)
{ }
template <typename... TArgs>
auto operator ()(TArgs&&... args) const
-> decltype(this->func(std::forward<TArgs>(args)...))
{
return func(std::forward<TArgs>(args)...);
}
private:
Func func;
};
这会产生编译器错误:
scratch.cpp:34:25: error: invalid use of ‘this’ at top level
我的编译器是g++ 4.6.2.
我的解决方法是声明一个self与类相同类型的静态成员,它有两个问题:
this那样自动获取CV限定符.decltype否则它无法看到成员(虽然这看起来更像是编译器错误).我正在使用Gradle 2.1并且有一个ANT任务定义如下:
task myTask {
doFirst {
ant.taskdef(name: 'mytask',
classname: 'com.blah.Blah',
classpath: configurations.gen.asPath
)
ant.mytask(foo: 'bar')
}
}
有一个属性我需要传递给com.blah.Blah作为JVM参数(因为,这个ANT任务的创建者决定系统属性是传递信息的合理方式,而不是像在参数中传递参数值那样理智.我尝试了很多东西,包括:
使用以下命令设置systemProperty所有任务JavaForkOptions:
tasks.withType(JavaForkOptions) {
systemProperty 'myproperty', 'blah'
}
-Dmyproperty=blah我调用时传递gradle.ant.systemPropery,ant.options.forkOptions,ant.forkOptions等(我不能真正找到这个随时随地可靠的文档)我在这里不知所措.这感觉就像我应该可以这样说:
task myTask {
doFirst {
ant.taskdef(name: 'mytask',
classname: 'com.blah.Blah',
classpath: configurations.gen.asPath
)
ant.systemProperty 'myProperty', 'blah'
ant.mytask(foo: 'bar')
}
}
......但这显然不起作用.
这似乎是一个非常愚蠢的问题,但我无法理解为什么这样使用Optional<T>编译:
import java.util.Optional;
public class Driver {
static void foo(Optional<String> x) { }
public static void main() {
foo(Optional.empty());
}
}
Optional::empty被定义为给我一个回报Optional<T>.在里面Driver::main,表达Optional.empty()似乎会返回一个Optional<Object>,因为我没有参数化使用,Optional所以我希望它回退Object为类型参数.然后,我将传递Optional<Object>给一个函数,该函数需要一个Optional<String>参数的向下转换,这是不允许的.我希望看到类似的东西:
incompatible types: Optional<Object> cannot be converted to Optional<String>
但是,代码编译完全正常.显然,我的思维过程不正确......但在哪里？
让我在这里的答案中澄清我正在寻找的内容......我知道什么是类型推断.我不明白它是如何发生的,以及从Java 7到Java 8的语言发生了什么变化.例如,这些代码在Java 8中编译得非常好,但在Java 7中失败了:
final class Opt<T> {
private final T value;
Opt(T x) {
value = x;
}
public static <T> Opt<T> empty() { …