什么东东？

auto increment

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

看帖 帮顶

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

我写的代码：
CardId.h
[code]
#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
[/code]

#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

闲得无聊，我写了一个

#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

呵呵，有点长

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;

}

引用 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…

你太猛了吧。