卡号分配程序实现

[张金富]

试一试

[mosaic]

什么东东？

[hhyttppd]

auto increment

[张金富]

公司让写一个卡号分配程序，卡号为八位，字符为26个字母（不区分大小写）加1至9九个数字，共35个字符。需要写两个功能：1、从某号段到某号段；2、从起始段往后N个卡号。需要区分卡号是否已经被分配，所以需要存入文件。
我是个新手，完全没有经验。我是这样设计的：卡号是35进制的，我为它写一个CardId类，重载运算符；然后设计一个类，有三个数据成员（CardId start，CardId end，long long total）。

[beyond071]

看帖 帮顶

[张金富]

建立一个二进制文件CardId.dat，存的Container类对象，读入放进一个容器内。然后在内存中比较输入的卡号是否已分配，如果没有则放入容器，最后将容器内的Container类对象存入CardId.dat，覆盖以前的内容。你们看设计的怎么样？

[张金富]

我写的代码：
CardId.h

#define CARDID_H
#include <iostream>
#include <cstring>
using namespace std;

const string CH = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
const int SIZE = 8;

class CardId
{
public:
      CardId();
      CardId(string str); 
      string getStr();
      void setStr(string str);
      CardId add(long long l);
      long long subtract(CardId &secondCardId);
      int compareTo(CardId &secondCardId);
      
      bool operator<(CardId &secondCardId);
      bool operator<=(CardId &secondCardId);
      bool operator>(CardId &secondCardId);
      bool operator>=(CardId &secondCardId);
      
      CardId operator+(long long l);
      long long operator-(CardId &secondCardId);
      
      friend ostream &operator<<(ostream &stream, CardId &cardId);
      friend istream &operator>>(istream &stream, CardId &cardId);
      
private:
      string str; 
      static long long stol(CardId cardId); 
      static  CardId ltos(long long l);    
};

#endif

[张金富]

#define CARDID_H
#include <iostream>
#include <cstring>
using namespace std;

const string CH = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
const int SIZE = 8;

class CardId
{
public:
CardId();
CardId(string str);
string getStr();
void setStr(string str);
CardId add(long long l);
long long subtract(CardId &secondCardId);
int compareTo(CardId &secondCardId);

bool operator<(CardId &secondCardId);
bool operator<=(CardId &secondCardId);
bool operator>(CardId &secondCardId);
bool operator>=(CardId &secondCardId);

CardId operator+(long long l);
long long operator-(CardId &secondCardId);

friend ostream &operator<<(ostream &stream, CardId &cardId);
friend istream &operator>>(istream &stream, CardId &cardId);

private:
string str;
static long long stol(CardId cardId);
static CardId ltos(long long l);
};

#endif

[hhyttppd]

闲得无聊，我写了一个

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

#define NOREACH()

namespace{
	//卡号的长度
	const unsigned int kCardLenght = 8;

	//有效卡字符
	const char kCardAlphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

	#define ARRAYSIZE(x) sizeof(x) / sizeof(0[x])

	//卡字母类型
	enum CardAlphabetType
	{
		UNKNOWN_TYPE = -1,
		DIGIT_TYPE = 0,
		CHAR_TYPE = 1
	};

	//检查器使用的格式标志
	const unsigned char kSegFlags = 0xF0;
	const unsigned int  kSegBits = 8;

#define ALPHA(c) (c - 'A')
#define DIGIT(d) (d - '0' + 26)

	//第一段
	// AG-AH
	const int kSegOneBegin[] = {ALPHA('A'), ALPHA('G')};
	const int kSegOneEnd[] = {ALPHA('A'), ALPHA('G')};
	const CardAlphabetType kSegOneType = CHAR_TYPE;

	//第二段
	//21-22
	const int kSegTwoBegin[] = {DIGIT('2'), DIGIT('1')};
	const int kSegTwoEnd[] = {DIGIT('2'), DIGIT('1')};
	const CardAlphabetType kSegTwoType = DIGIT_TYPE;

	//第三段
	//A-Z
	const int kSegThreeBegin[] = {ALPHA('A')};
	const int kSegThreeEnd[] = {ALPHA('B')};
	const CardAlphabetType kSegThreeType = CHAR_TYPE;

	//第二段
	//1001-2002
	const int kSegFourBegin[] = {DIGIT('1'), DIGIT('0'),DIGIT('0'), DIGIT('1')};
	const int kSegFourEnd[] = {DIGIT('1'), DIGIT('0'),DIGIT('0'), DIGIT('2')};
	const CardAlphabetType kSegFourType = DIGIT_TYPE;
}//namespace

[hhyttppd]

呵呵，有点长

namespace Card
{
	//卡号段
	//比如四位数字 0000-9999
	//三位字母  AAA-ZZZ
	//如果当前段无法表示，则可以要求高位递增
	//卡号字符全局用下标表示
	class CardSegment
	{
	public:
		CardSegment(vector<int> seg_range_begin, vector<int> seg_range_end, CardAlphabetType type)
			:seg_range_begin_(seg_range_begin),
			seg_range_end_(seg_range_end),
			seg_current_(seg_range_begin),
			seg_bit_range_begin_(type == CHAR_TYPE ? 0 : type == DIGIT_TYPE ? 26 : -1),
			seg_bit_range_end_(type == CHAR_TYPE ? 25 : type == DIGIT_TYPE ? 35 : -1),
			seg_bit_status_(seg_range_end_.size(), FILL)
		{		
				UpdateBitState();
		}

		CardSegment(vector<int> seg_range_begin, vector<int> seg_range_end, vector<int> seg_current, CardAlphabetType type)
			:seg_range_begin_(seg_range_begin),
			seg_range_end_(seg_range_end),
			seg_current_(seg_current),
			seg_bit_range_begin_(type == CHAR_TYPE ? 0 : type == DIGIT_TYPE ? 26 : -1),
			seg_bit_range_end_(type == CHAR_TYPE ? 25 : type == DIGIT_TYPE ? 35 : -1)
		{
			UpdateBitState();
		}

		//将卡号段重置
		void Reset()
		{
			seg_current_.clear();
			copy(seg_range_begin_.begin(), seg_range_begin_.end(), back_inserter(seg_current_));

			UpdateBitState();
		}

		bool NextCardNoReturn()
		{
			bool find = false;

			if(!IsFull())
			{
				//更新低位
				IncrementMostLowBit(static_cast<int>(seg_current_.size()) - 1);
				UpdateBitState();
				find = true;
			}
			
			return find;
		}

		//获取一下卡号
		void GetCurSeg(vector<int>& seg)
		{
			seg.clear();
			copy(seg_current_.begin(), seg_current_.end(), back_inserter(seg));
			reverse(seg.begin(), seg.end());
		}

		//是否可以更新
		bool IsFull()
		{
			int size = static_cast<int>(seg_bit_status_.size()); 
			for(int i = 0; i < size; i++)
			{
				if(GetBitState(i) == FILL)
				{
					return false;
				}							
			}

			return true;
		}

	private:
		enum SegBitState
		{
			FULL = 0,              //已满
			FILL = 1               //未满
		};

		//设置位的状态
		void SetBitState(int bit, SegBitState state)
		{
			seg_bit_status_[bit] = state;
		}

		SegBitState GetBitState(int bit){return seg_bit_status_[bit];}

		//对比seg_current_与seg_range_end_
		//更新各位的状态
		void UpdateBitState()
		{
			int size = static_cast<int>(seg_current_.size()); 
			for(int i = 0; i < size; i++)
			{
				if(seg_current_[i] >= seg_range_end_[i])	
					SetBitState(i, FULL);
				else
					SetBitState(i, FILL);
			}			
		}

		//找到高位，更新后位
		void IncrementMostLowBit(int cur)
		{
			if(cur < 0) 
			{
				NOREACH();
				return;
			}

			if(seg_current_[cur] >= seg_bit_range_end_)
			{
				//进位
				seg_current_[cur] = seg_bit_range_begin_;

				IncrementMostLowBit(cur - 1);
				return;
			}

			seg_current_[cur]++;
		}

	private:
		//段号范围
		vector<int> seg_range_begin_;   //一般用不上
		vector<int> seg_range_end_;
		vector<int> seg_current_;

		//每位的变化范围
		int seg_bit_range_begin_;
		int seg_bit_range_end_;

		//每位的当前状态
		vector<SegBitState> seg_bit_status_;
	};

	//卡号管理器
	class CardManager
	{
	private:
		CardManager()
			:last_used_(false)
		{
			vector<int> seg_four_range_beg(kSegFourBegin, kSegFourBegin + ARRAYSIZE(kSegFourBegin));
			vector<int> seg_four_range_end(kSegFourEnd, kSegFourEnd + ARRAYSIZE(kSegFourEnd));

			CardSegment seg_four(seg_four_range_beg, seg_four_range_end, kSegFourType);

			AppendCardSegment(seg_four);

			vector<int> seg_three_range_beg(kSegThreeBegin, kSegThreeBegin + ARRAYSIZE(kSegThreeBegin));
			vector<int> seg_three_range_end(kSegThreeEnd, kSegThreeEnd + ARRAYSIZE(kSegThreeEnd));

			CardSegment seg_three(seg_three_range_beg, seg_three_range_end, kSegThreeType);

			AppendCardSegment(seg_three);

			vector<int> seg_two_range_beg(kSegTwoBegin, kSegTwoBegin + ARRAYSIZE(kSegTwoBegin));
			vector<int> seg_two_range_end(kSegTwoEnd, kSegTwoEnd + ARRAYSIZE(kSegTwoEnd));

			CardSegment seg_two(seg_two_range_beg, seg_two_range_end, kSegTwoType);

			AppendCardSegment(seg_two);

			vector<int> seg_one__range_beg(kSegOneBegin, kSegOneBegin + ARRAYSIZE(kSegOneBegin));
			vector<int> seg_one_range_end(kSegOneEnd, kSegOneEnd + ARRAYSIZE(kSegOneEnd));

			CardSegment seg_one(seg_one__range_beg, seg_one_range_end, kSegOneType);

			AppendCardSegment(seg_one);


		}

		virtual ~CardManager()
		{
		}

	public:
		//单件
		static CardManager& Instance(){return manager_;}

	public:
		void AppendCardSegment(CardSegment& seg)
		{
			seg_list_.push_back(seg);
		}

	public:
		//获取卡号
		bool GetCardNumber(string& number)
		{
			vector<int> idx;
			bool succ = GetCardNumberIdx(idx);

			if(succ)
			{
				number = CardIndexToString(idx);
			}

			return succ;
		}

		//从下标转为字符串
		static string CardIndexToString(vector<int>& pos)
		{
			string card_number;

			for(vector<int>::const_iterator itr = pos.begin(); itr != pos.end(); ++itr)
			{
				card_number.append(1, kCardAlphabet[*itr]);
			}

			return card_number;
		}

		bool IsCardNumberFull()
		{
			for(size_t i = (size_t)0; i < seg_list_.size(); i++)
			{
				if(!seg_list_[i].IsFull())
				{
					return false;
				}
			}

			return true;
		}
		
	private:
		bool GetCardNumberIdx(vector<int>& number)
		{
			if(!IsCardNumberFull())
			{
				GetCurrentCardNumber(number);
				IncrementMostLowSegment(0);
				return true;
			}
			else if(last_used_ == false)
			{
				last_used_ = true;
				GetCurrentCardNumber(number);
				return true;
			}

			return false;
		}

		void GetCurrentCardNumber(vector<int>&  number)
		{
			vector<int> seg;

			number.clear();

			for(int i = static_cast<int>(seg_list_.size()) - 1; i >= 0; i--)
			{
				seg.clear();
				seg_list_[i].GetCurSeg(seg);
				reverse(seg.begin(), seg.end());
				copy(seg.begin(), seg.end(), back_inserter(number));
			}

		}

		void IncrementMostLowSegment(int cur)
		{
			if(cur > static_cast<int>(seg_list_.size())) 
			{
				NOREACH();
				return;
			}

			if(seg_list_[cur].IsFull())
			{
				//进位
				seg_list_[cur].Reset();

				IncrementMostLowSegment(cur+1);
				return;
			}	

			seg_list_[cur].NextCardNoReturn();
		}

	private:	
		//卡号段
		vector<CardSegment> seg_list_;

		//最后一个号码
		bool last_used_;

		static CardManager manager_;
	};
	CardManager CardManager::manager_;
}  //namespace

using namespace Card;
int _tmain(int argc, _TCHAR* argv[])
{

	for(int i = 0; i < 100; i++)	
	{
		string card_number;
		if(CardManager::Instance().GetCardNumber(card_number))
			cout << card_number << endl;
		else
		{
			cout << "no any more card..." << endl;
			break;
		}
	}

	return 0;
}

[chin_chen]

[Quote=引用 9 楼 hhyttppd 的回复:]
呵呵，有点长
C/C++ codenamespaceCard
{//卡号段//比如四位数字 0000-9999//三位字母 AAA-ZZZ//如果当前段无法表示，则可以要求高位递增//卡号字符全局用下标表示classCardSegment
{public:
CardSegment(vector<int>seg_range_begin, vector<int>seg_range_end, CardAlphabetType type)
:seg_range_begin_(seg_range_begin),
seg_range_end_(seg_range_end),
seg_current_(s…
[/Quote]
你太猛了吧。