小编klo*_*ffy的帖子

这可能非常明显,但为什么boost中的基于流的解析复制了最后一个字母？我一定做错了什么:

#include <iostream>
#include <sstream>

#include <boost/spirit/include/qi.hpp>

namespace qi = boost::spirit::qi;

int main() {
    std::string input = "hello";
    std::stringstream ss(input);

    std::string r1, r2;
    boost::spirit::istream_iterator first(ss), last;

    qi::phrase_parse(input.begin(), input.end(), qi::lexeme[qi::alpha >> *qi::alnum], qi::space, r1);

    std::cout << r1 << std::endl; // prints "hello"

    qi::phrase_parse(first, last, qi::lexeme[qi::alpha >> *qi::alnum], qi::space, r2);

    std::cout << r2 << std::endl; // prints "helloo"
}

使用XCode 5.0和Boost 1.54.0进行测试.

编辑: 问题似乎是特定于libc ++.有人使用Clang护理确认吗？

我想知道Boost.Spirit.Qi中是否有一种方法可以在运行时动态组合任意数量的规则.Boost.Spirit的内部工作方式对我来说仍然有点神秘,但由于规则被实现为对象似乎是可行的.我的动机是让我的语法的某些部分容易扩展.

考虑以下人为的例子:

namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;

typedef std::string::const_iterator iterator_t;

template<typename Expr>
inline bool parse_full(const std::string& input, const Expr& expr)
{
    iterator_t first(input.begin()), last(input.end());

    bool result = qi::phrase_parse(first, last, expr, boost::spirit::ascii::space);

    return first == input.end() && result;
}

void no_op() {}

int main(int argc, char *argv[]) 
{
    int attr = -1;

    // "Static" version - Works fine!
    /*
    qi::rule<iterator_t, void(int&)> grammar;

    qi::rule<iterator_t, void(int&)> ruleA = qi::char_('a')[qi::_r1 = px::val(0)];
    qi::rule<iterator_t, void(int&)> ruleB = qi::char_('b')[qi::_r1 = px::val(1)];
    qi::rule<iterator_t, void(int&)> …

我一直在玩Json.NET,我很喜欢它.但是,在使用值类型成员反序列化对象时遇到了问题.例如,考虑以下代码:

public struct Vector
{
    public float X;
    public float Y;
    public float Z;

    public override string ToString()
    {
        return string.Format("({0},{1},{2})", X, Y, Z);
    }
}

public class Object
{
    public Vector Position;
}

class Program
{
    static void Main(string[] args)
    {
        var obj = new Object();
        obj.Position = new Vector { X = 1, Y = 2, Z = 3 };

        var str = JsonConvert.SerializeObject(obj);

        Console.WriteLine(str); // {"Position":{"X":1.0,"Y":2.0,"Z":3.0}}

        obj = JsonConvert.DeserializeObject<Object>(str);

        Console.WriteLine(obj.Position); // (0,0,0)

        Console.ReadKey(true);
    }
} …

我知道不应该使用类别来覆盖它们正在扩展的类中的方法.但是,下面的场景呢？

考虑这些课程:

Base.h

#import <Foundation/NSObject.h>

@interface Base: NSObject { NSNumber *n; }
@end

Derived.h

#import "Base.h"

@interface Derived: Base { NSString *s; }
@end

有类别:

基地+ Serialize.h

#import "Base.h"

@interface Base (Serialize)
- (NSString*)serialize;
@end

基地+ Serialize.m

#import "Base+Serialize.h"

@implementation Base (Serialize)
- (NSString*)serialize
{
    return [NSString stringWithFormat:@"%@", n];
}

@end

派生+ Serialize.h

#import "Derived.h"

#import "Base+Serialize.h"

@interface Derived (Serialize)
- (NSString*)serialize;
@end

派生+ Serialize.m

#import "Derived+Serialize.h"

@implementation Derived (Serialize)
- (NSString*)serialize
{
    return [NSString stringWithFormat:@"%@, %@", s, [super serialize]]; …

移动语义对RAII类很有用.它们允许一个人编程,好像一个人有价值语义而没有沉重的副本.一个很好的例子是从函数返回std :: vector.然而,使用值语义进行编程意味着,人们会期望类型的行为类似于原始数据类型.这两个方面有时似乎不一致.

一方面,在RAII中,人们会期望默认构造函数返回完全初始化的对象,或者如果资源获取失败则抛出异常.这可以保证任何构造的对象都处于有效且一致的状态(即安全使用).

另一方面,对于移动语义,当对象处于有效但未指定的状态时存在一个点.类似地,原始数据类型可以处于未初始化状态.因此,使用值语义,我希望默认构造函数在此有效但未指定的状态下创建对象,以便以下代码具有预期的行为:

// Primitive Data Type, Value Semantics
int i;
i = 5;

// RAII Class, Move Semantics
Resource r;
r = Resource{/*...*/}

在这两种情况下,我都希望"重"初始化只发生一次.我想知道,这方面的最佳做法是什么？显然,第二种方法存在一些实际问题:如果默认构造函数在未指定状态下创建对象,那么如何编写一个获取资源的构造函数,但不采用其他参数？(标记调度会浮现在脑海中......)

编辑:一些答案质疑试图让你的类像原始数据类型一样工作的理由.我的一些动机来自亚历山大·斯捷潘诺夫(Alexander Stepanov)的"高效编程与组件"(Efficient Programming with Components),他讲述了常规类型 特别是,让我引用一下:

无论c [内置类型]中的自然惯用表达是什么,都应该是常规类型的自然惯用表达式.

他继续提供与上面几乎相同的例子.他的观点在这方面是否有效？我理解错了吗？

编辑:由于没有太多的讨论,我即将接受最高投票的答案.在默认构造函数中以"从 - 移动状态"状态初始化对象可能不是一个好主意,因为每个同意现有答案的人都不会期望这种行为.

在IronPython中使用.NET值类型时有一个众所周知的问题.最近,当我尝试在C#中使用Python作为嵌入式脚本语言时,这让我很头疼.问题可归纳如下:

给定一个C#结构,例如:

struct Vector {
    public float x;
    public float y;
}

还有一个C#类如:

class Object {
    public Vector position;
}

IronPython中将发生以下情况:

obj = Object()
print obj.position.x    # prints ‘0’
obj.position.x = 1
print obj.position.x    # still prints ‘0’

正如文章所述,这意味着价值类型大多是不可变的.但是,这是一个问题,因为我计划使用如上所示实现的矢量库.是否有任何变通方法可以使用依赖于值类型的现有库？修改库将是最后的手段,但我宁愿避免这种情况.

Boost.Program_options 提供了一种通过命令行参数传递多个令牌的工具，如下所示：

std::vector<int> nums;    

po::options_description desc("Allowed options");
desc.add_options()
    ("help", "Produce help message.")
    ("nums", po::value< std::vector<int> >(&nums)->multitoken(), "Numbers.")
;

po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);

但是，只接受固定数量参数的首选方式是什么？我能来的唯一解决方案是手动分配值：

int nums[2];    

po::options_description desc("Allowed options");
desc.add_options()
    ("help", "Produce help message.")
    ("nums", "Numbers.")
;

po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);

if (vm.count("nums")) {
   // Assign nums
}

这感觉有点笨拙。有更好的解决方案吗？

我正在处理一些缺少值的数据,这些数据只是表示为Maybe值列表.我想执行各种聚合/统计操作,它们只是忽略了缺失的值.

这与以下问题有关:

习惯于在haskell中汇总Maybe Int列表的方法

如何使用may monoid并将值与自定义操作相结合？

但是,Nothing如果缺少任何值,前一个问题就是返回内容,这在我的情况下不是一个选项.我有一个涉及创建Num实例的解决方案Maybe.但是,这意味着它特定于加法和乘法,它也有一些其他问题.

instance Num a => Num (Maybe a) where
  negate      = fmap negate
  (+)         = liftA2 (+)
  (*)         = liftA2 (*)
  fromInteger = pure . fromInteger
  abs         = fmap abs
  signum      = fmap signum

基于此,我们可以做这样的事情:

maybeCombineW :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
maybeCombineW f (Just x)  (Just y)  = Just (f x y)
maybeCombineW _ (Just x)  Nothing   = …

在下面的示例中，有什么方法可以使用 CSS 截断单元格中的文本（而不是让它环绕或溢出）？理想情况下，CSS 应如下所示：

.truncate {
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

但是正如您在下面看到的，这只会导致单元格消耗所有空间：

<!DOCTYPE html>
<html>
<head>
  <link href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900" rel="stylesheet">
  <link href="https://cdn.jsdelivr.net/npm/@mdi/font@4.x/css/materialdesignicons.min.css" rel="stylesheet">
  <link href="https://cdn.jsdelivr.net/npm/vuetify@2.x/dist/vuetify.min.css" rel="stylesheet">
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, minimal-ui">
  <style>
.truncate {
  display: inline-block;
  /* width: 200px; */
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}
  </style>
</head>
<body>
  <div id="app">
<v-app>
  <v-content>
    <v-data-table :headers="headers" :items="items">
      <template v-slot:item.name="{ item }">
        <span class="truncate">{{ item.name}}</span>
      </template>
    </v-data-table>
  </v-content>
</v-app>
  </div>

  <script src="https://cdn.jsdelivr.net/npm/vue@2.x/dist/vue.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/vuetify@2.x/dist/vuetify.js"></script>
  <script>
new Vue({
  el: …