小编Tho*_*ing的帖子

假设我在C++中有以下内容:

char buffer[SIZE];
char * ptr = &buffer[SIZE];

哪里ptr的价值永远不会被取消引用.这样做C++是否合法？那是使用从数组的最后一个元素开始的内存地址(比如作为要比较的特殊值)？

在下面的程序中,我只希望cycle3以恒定的内存运行(它明确地结合了结).然而,cycle2由于我无法理解的原因,也会在恒定的内存中运行.我希望cycle2做完全相同的工作,如cycle1因为

xs' = xs ++ xs'
xs' = xs ++ xs ++ xs' -- substitute value of xs'
xs' = xs ++ xs ++ xs ++ xs' -- substitute value of xs' again
xs' = xs ++ xs ++ xs ++ ... -- and so on

有人可以解释我在这里缺少的东西吗？

module Main where

import System.Environment (getArgs)

cycle1 :: [a] -> [a]
cycle1 [] = error "empty list"
cycle1 xs = xs ++ cycle1 xs

cycle2 …

假设我有以下Haskell代码:

data Option
    = Help
    | Opt1 Int Double String
    -- more options would be here in a real case

handleOption :: Option -> IO ()
handleOption option = case option of
    Help -> handleHelp
    Opt1 n f s -> handleOpt1 n f s

handleHelp :: IO ()
handleHelp = print "help"

handleOpt1 :: Int -> Double -> String -> IO ()
handleOpt1 n f s = print (n, f, s)

在上面的代码中,在我可以将数据整齐地捆绑在一起的意义上提前解构对象似乎是浪费.现在我必须单独传递Opt1的每个部分,或者创建一个单独的数据类型来拖运它们.是否有可能在整个传递Opt1到handleOpt1同时不允许一般的Option情况下被传递的,比如做handleOpt1 Help …

有什么样rbegin并rend进行指点？

我有指向c风格字符串的头部和尾部的指针,但是想为它们创建反向迭代器.

我想知道是否有办法由标准提供,或者我必须为此编写自己的代码.

编辑:我使用低级代码是有原因的.不std::basic_string,等等.目标是用于std::find查找值的最后一次出现.

假设在CI中具有这些功能

type* func (type*);
const type* func_const (const type*);

这样它们都具有完全相同的内部逻辑.

有没有办法可以将两者合并为一个函数,如果给定一个const类型,它返回一个const类型; 如果给定一个非const类型,它返回一个非const类型？如果没有,处理这个问题的好方法是什么？也许通过显式铸造来定义另一个？

假定一个类及其所有子类只需要默认的析构函数来释放它们的资源(如果存储在精确类型的变量中(或指向精确类型的指针)),如果由基类指针引用,则子类可以泄漏内存.然后被那个指针删除？

例:

#include <memory>

class A {
};

class B : public A {
public:
    B () : pInt(new int) {}
    auto_ptr<int> pInt; // this is what might leak... possibly more will though
};

void will_this_leak () {
    A *pA = new B();
    delete pA;
}

我有用任何编程语言编写的代码.我如何"美化"它(大胆的,如果,否则等)在网站上显示？有没有好的API可以做到这一点？

我很难使用zoom给出的函数Control.Lens.使用我的定制monad变换器HearthMonad,我无法弄清楚如何满足GHC的"模糊类型"投诉.

有问题的代码在drawCard.

我怎么解决这个问题？我一定要创建自己的自定义缩放操作来处理Monad m的Hearth m？

{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TemplateHaskell #-}


module EngineZoom where


--------------------------------------------------------------------------------


import Control.Applicative
import Control.Lens
import Control.Monad.State
import Data.List
import Data.Maybe


--------------------------------------------------------------------------------


type PlayerHandle = String


data Card = Card String
    deriving (Show, Eq, Ord)


data Player = Player {
    _playerHandle :: PlayerHandle,
    _hand :: [Card]
} deriving (Show, Eq, …

以下是否导致明确定义的行为？也就是说,如果你将非vararg函数f作为vararg函数g转换并使用f期望的参数调用g,那么行为是否与使用这些参数调用f的行为相匹配？

class Base {};

class Derived1 : public Base {
public:
    int getInt1() {return 1;}
};

class Derived2 : public Base {
public:
    int getInt2() {return 2;}
};

typedef int (*vfunc)(...);

int foo (vfunc f) {
    Derived1 d1;
    Derived2 d2;
    return f(&d1, &d2);
}

int bar (Derived1 * p1, Derived2 * p2) {
    return p1->getInt1() + p2->getInt2();
}

int main (int argc, char ** argv) {
    return foo((vfunc)bar); // Is this program guaranteed to return 3?
}

UPDATE

有没有什么方法可以让程序定义明确,即使使用专有关键字？比如做一些像__cdecl …

返回类型"指向成员的指针"的语法是什么？

struct Point {
    int x;
    int y;
    int z;
};

// compiles
decltype(&Point::x) getX () {
   return &Point::x;
}

// does not compile... how to do this without decltype?
int (Point::*) getX () {
   return &Point::x;
}


// Use case:
Point p, q;
auto pm = getX();
p.*pm = 1;  // p.x = 1
q.*pm = 2;  // q.x = 2