Привет всем 🙂 Надеюсь, у кого-нибудь найдется решение или я наконец найду ^^
Я новичок в C ++, поэтому, объект, шаблон и итератор, может быть, я немного понимаю и внесу некоторые изменения, но я не могу манипулировать им, когда это сложно.
Я создаю программное обеспечение, используя диапазон рук, чтобы оценить вероятность в игре в покер.
Я пользуюсь библиотекой покерной печи. https://github.com/andrewprock/pokerstove .
В покере мы чаще всего оцениваем вероятность выигрыша одной руки против другой. Но мы не знаем руку противника: поэтому мы манипулируем диапазоном или набором рук. Здесь рука (2 карты) — это CardSet структура из покерстоува. Итак, я должен сделать набор манипуляций, таких как пересечение, разница и объединение.
У меня проблема с union_set, но не с set_difference:
std::set<CardSet> union_range;
std::set<CardSet> ensemble_main1=union_range;
std::set<CardSet> ensemble_main2=pourcent_stove(30.);//=range_action(action[0][j][1],j);
std::set<CardSet> ensemble_main=pourcent_stove(20.); //=resultat;
set_difference(ensemble_main1.begin(),ensemble_main1.end(),ensemble_main2.begin(),ensemble_main2.end(),std::inserter(ensemble_main,ensemble_main1.begin()));
Работает. pourcent_stove (30.) дает набор лучших 30% 2 карт из набора лучших рук в безлимитном холдеме.
Но:
std::set<CardSet> union_range;
std::set<CardSet> ensemble_main1=union_range;
std::set<CardSet> ensemble_main2=pourcent_stove(30.);//=range_action(action[0][j][1],j);
std::set<CardSet> ensemble_main=pourcent_stove(20.); //=resultat;
set_union(ensemble_main1.begin(),ensemble_main1.end(),ensemble_main2.begin(),ensemble_main2.end(),std::inserter(ensemble_main,ensemble_main1.begin()));
не работает: у меня есть Segfault.
Я полагаю, что проблема здесь, потому что объединение может увеличить количество элементов. У вас есть идея о линии, которую я могу добавить?
Я попытался сделать итератор push_back. Но без успеха. Было написано, что метод не существует для этого объекта.
Я также попытался сделать объявление размера для набора с использованием синтаксиса вектора: без успеха
У меня недостаточно репутации для размещения ссылок на документ, который я использовал. (Максимум 2 ссылки)
Я должен написать адрес лицензии, чтобы уважать авторов: https://github.com/andrewprock/pokerstove/blob/master/LICENSE.txt
/**
* Copyright (c) 2012 Andrew Prock. All rights reserved.
* $Id: CardSet.h 2649 2012-06-30 04:53:24Z prock $
*/
#ifndef PEVAL_CARDSET_H_
#define PEVAL_CARDSET_H_
#include <iosfwd>
#include <vector>
#include <string>
#include <boost/cstdint.hpp>
#include "Rank.h"#include "Suit.h"
namespace pokerstove
{
// forward declares
class Card;
class PokerEvaluation;
/**
* The CardSet is a compact representation of an unordered set of
* cards. All evaluation is done at the CardSet level.
*
* It can be used to store set of cards such as seen cards, dead
* cards, folded cards, door cards, and whatever generic set of cards
* you may be interested in.
*
* CardSet is implemented with efficiency in mind, so when selecting
* from representations for cards, use a CardSet if speed and size
* efficiency is important. Other containers may be less efficient in
* terms of size, speed, or both.
*/
class CardSet
{
public:
static const size_t STANDARD_DECK_SIZE = Rank::NUM_RANK* Suit::NUM_SUIT;
public:
CardSet(); //!< defaults to the empty set
CardSet(const CardSet& cs); //!< copy constructor (default)
CardSet(const std::string& c); //!< parse cards untill fail
explicit CardSet(const Card& c); //!< create a set with one card
explicit CardSet(uint64_t mask) : _cardmask(mask) {}
void clear() { _cardmask = 0; } //!< empty the set
void fill() { _cardmask = 0; _cardmask = ~_cardmask; } //!< put all cards into the set
size_t size() const; //!< return number of cards in set
uint64_t mask() const { return _cardmask; } //!< 1 bit per card
std::vector<Card> cards() const; //!< break into Cards
std::vector<CardSet> cardSets() const; //!< break into one card/CardSet
/**
* Card related methods.
*/
bool contains(const Card& c) const; //!< is a card in the set
bool contains(const CardSet& c) const; //!< is a card in the set
CardSet& insert(const Card& c); //!< add one card
CardSet& insert(const CardSet& c); //!< equivalent to |=
CardSet& remove(const Card& c); //!< remove a card
CardSet& remove(const CardSet& c);
bool disjoint(const CardSet& c) const { return (_cardmask & c._cardmask) == 0; }
bool intersects(const CardSet& c) const { return !disjoint(c); }
/**
* Rank related methods.
*/
size_t countRanks() const;
size_t count(const Rank& r) const;
bool contains(const Rank& r) const;
Card find(const Rank& r) const; //!< return some card with rank r, in suit order
int rankMask() const; //!< one bit set for each rank in hand, 13 max
bool hasStraight() const;
Rank topRank() const; //!< return the highest rank in hand
Rank bottomRank() const; //!< return lowest rank in hand (A plays high)
size_t countMaxRank() const; //!< return the number of the most common rank
bool insertRanks(const CardSet& rset); //!< add ranks to hand, any suit
CardSet canonizeRanks() const; //!< create a canonical rank representation
/**
* Suit related methods.
*/
size_t countSuits() const; //!< number of different suits in hand
size_t count(const Suit& s) const; //!< returns the length of the specified suit
size_t countMaxSuit() const; //!< returns the length of the longest suit
bool contains(const Suit& s) const;
Rank flushRank(const Suit& s) const; //!< return the highest rank of specified suit
int suitMask(const Suit& s) const;
CardSet canonize() const; //!< transform suits to canonical form
CardSet canonize(const CardSet& other) const; //!< canonize relative to other hand
CardSet rotateSuits(int c, int d, int h, int s) const;
void flipSuits(); //!< invert suit order {cdhs} -> {shdc}
/**
* String conversions. Note that the output produced depends on
* Suit::setSuitStringType (Suit::display s). Not all string types are
* reparseable. That is:
*
* CardSet (CardSet("Ac").str()) == CardSet("Ac")
*
* May not be true.
*
* It is guaranteed to be true if the Suit::display type is SUIT_ASCII
*/
std::string str() const;
std::string rankstr() const; //!< print sorted ranks with dupes
std::string toRankBitString() const;
/**
* indexing utils
*/
size_t colex() const; //!< return a unique number based on cards
size_t rankColex() const; //!< return a unique number based on ranks
/**
* These are the basic building blocks of evaluation, they should
* be fairly fast, but general, note there is a chance some of
* these may break if given degenerate sets (with no cards, or
* more than 7 cards) Every evaluation is ordered such that
* (better hand) > (worse hand). This holds even for (esp for)
* lowball. There is also a code which represents an null hand,
* specifcally for the case of not making a qualifying 8 low.
*
* There is a tradeoff putting them here, by keeping them here we
* preserve encapsulation but clutter up the class. It might be
* better to separate these out into utility functions.
* e.g. PokerEvaluation evaluateHigh(const CardSet& c);
*/
PokerEvaluation evaluateHigh() const;
PokerEvaluation evaluateHighRanks() const;
PokerEvaluation evaluateHighFlush() const;
//PokerEvaluation evaluateHighThreeCard() const;
PokerEvaluation evaluateLowA5() const;
PokerEvaluation evaluate8LowA5() const;
PokerEvaluation evaluateLow2to7() const;
PokerEvaluation evaluateRanksLow2to7() const;
PokerEvaluation evaluateSuitsLow2to7() const;
PokerEvaluation evaluate3CP() const;
PokerEvaluation evaluateBadugi() const;
PokerEvaluation evaluatePairing() const;
// sub evaluations
/** return the number of outs to complete a straight
* returns 8 for open ended
* returns 4 for gutshot
* returns 1 for runner runner
*/
int evaluateStraightOuts() const;
// overloaded operators, syntactic sugar. It is no secret that
// this is a bitset, so exposing bit operations should be ok.
// one thing that should be considered is implementing the &=, etc
// operators for efficiency and generality using boost::opperators
void operator|= (const CardSet& c) { _cardmask |= c._cardmask; }
void operator^= (const CardSet& c) { _cardmask ^= c._cardmask; }
bool operator== (const CardSet& c) const { return _cardmask == c._cardmask; }
bool operator!= (const CardSet& c) const { return _cardmask != c._cardmask; }
bool operator< (const CardSet& c) const { return _cardmask < c._cardmask; }
bool operator> (const CardSet& c) const { return _cardmask > c._cardmask; }
CardSet operator& (const CardSet& c) const { return CardSet(_cardmask & c._cardmask); }
CardSet operator| (const CardSet& c) const { return CardSet(_cardmask | c._cardmask); }
CardSet operator^(const CardSet& c) const { return CardSet(_cardmask ^ c._cardmask); }
void swap(CardSet& c)
{
uint64_t t = c._cardmask;
c._cardmask = _cardmask;
_cardmask = t;
}
protected:
void fromString (const std::string& s); //!< throws exception on parse failre
bool isPaired () const; //!< returns true if *any* two cards match rank
bool isTripped () const; //!< returns true if trips
private:
//!< bit mask of cards in "canonical" order. [2c,3c ... Ac,Ad ... Ah ... Qs,Ks,As]
uint64_t _cardmask;
};
////////////////////////////////////////////////////////////////////////////////
// Below are standalone methods related to CardSet objects. They should
// probably be moved to a separate file as they don't directly manipulate
// CardSet data.
/////////////////////////////////////////////////////////////////////////////////**
* cannonize a hand relative to a board
*/
CardSet canonizeToBoard(const CardSet& board, const CardSet& hand);std::vector<int> findSuitPermutation(const CardSet& source, const CardSet& dest);
} // namespace pokerstove/**
* our little printer
*/
std::ostream& operator<<(std::ostream& sout, const pokerstove::CardSet& e);
#endif // PEVAL_CARDSET_H_
Спасибо за ваше чтение 🙂
Проблема последних аргументов обоих set_union
а также set_difference
, Второй аргумент std::inserter
должен быть итератором для контейнера, который передается в качестве первого аргумента. Но вы передаете итератор из другого контейнера:
std::inserter(ensemble_main, ensemble_main1.begin())
// ^^^^^^^^^^^^^^^^^^^^^^
// doesn't point in ensemble_main
Вы нарушаете предварительное условие для функции, и это приводит к неопределенному поведению. Дело в том, что set_difference
Похоже, это просто (не) счастливое совпадение.
Других решений пока нет …