プログラマ専用SNS ミクプラ

void shuffle( int* ary, int n ){
	int i,j,k;
	for(i = 0;i < n;++i) ary = i;
	for(i = 0;i < n-1;++i){
		j = i + (rand() % (n - i));
		k = ary[j];
		ary[j] = ary;
		ary = k;
	}
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 10

void shuffle(int* buf, int size);

int main(void)
{
	srand((unsigned)time(NULL));
	int data[N];

	shuffle(data, N);

	for (int i = 0; i < N; ++i)
	{
		printf("%d\n", data);
	}

	return 0;
}

void shuffle(int* data, int size)
{
	// 初期化
	for (int i = 0; i < N; ++i)
	{
		*(data + i) = i;
	}

	// シャッフル
	for (int i = 0; i < N - 1; ++i)
	{
		int id = rand() % (N - 1);
		int swap = *(data + id);
		*(data + id) = *(data + N - 1);
		*(data + N - 1) = swap;
	}
}

void shuffle(int* data, int size)
{
	// 初期化
	for (int i = 0; i < size; ++i)
	{
		*(data + i) = i;
	}

	// シャッフル
	for (int i = 0; i < size - 1; ++i)
	{
		int id = rand() % (size - 1);
		int swap = *(data + id);
		*(data + id) = *(data + size - 1);
		*(data + size - 1) = swap;
	}
}

今までのrandのような形で使いたいのかなと思い、こんなの用意してみました。

my_rand.hの内容は理解する必要ありません。
このままソースファイルと同じフォルダにこの名前で保存すればＯＫです。

my_srand(10,20);

と書くと、今後my_rand関数を呼べば10～20の数値のどれかが重複無く返ってきます。
この場合12回以上my_randを呼ぶとエラーになります。
my_rand.h内で領域を確保しているため、乱数を使い終わったら解放
delete_my_rand
する必要があるので注意して下さい。

基本的にmain.cppの内容だけ見てもらったら大丈夫かと思います。
設定して、乱数を呼んで、消去という流れです。
なお、main.cppという名前はこれでなくても構いません。

----------------------------------------------------------
/* my_rand.h */
----------------------------------------------------------

int *MyRandArrayPointer;	//乱数入れる入れ物
int MyRandCallNum;			//今何回呼ばれたか
int MyRandArrayNum;			//入れ物の個数

//my_srandで設定した乱数を順番に取り出す。
//エラーの場合0を返し、error_flagが-1になる。
int my_rand(int *error_flag){
	int ret;
	if(MyRandArrayNum<=MyRandCallNum){
		*error_flag=-1;
		return 0;
	}
	ret=*(MyRandArrayPointer + MyRandCallNum);
	MyRandCallNum++;
	*error_flag=0;
	return ret;
}

//from～toまでの乱数を設定する
//エラーの返り値は-1
int my_srand(const int from, const int to){
	int i,n;

	//toの方がfromが小さいか、intの扱える範囲を超えていたら
	if( (n = to+1-from) <= 0 || from<=-INT_MAX || to>=INT_MAX)
		return -1;//エラー

	//配列要素確保
	MyRandArrayPointer = (int *)malloc( n * sizeof(int) );

	//fromからtoまでを格納
	for( i=from ; i<=to ; i++ ){
		*MyRandArrayPointer=i;
		MyRandArrayPointer++;
	}

	//ポインタ戻す
	MyRandArrayPointer-=n;

	//シャッフル
	for ( i=0 ; i<n ; i++ ){
		int id = rand() % n;
		int swap = *(MyRandArrayPointer + id);
		*(MyRandArrayPointer + id) = *(MyRandArrayPointer + i);
		*(MyRandArrayPointer + i ) = swap;
	}

	MyRandCallNum=0;
	MyRandArrayNum=n;
	return 0;
}

void delete_my_rand(){
	free(MyRandArrayPointer);
}

----------------------------------------------------------
/* main.cpp */
----------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "my_rand.h"

int main(void){
	int error_flag;
	srand((unsigned)time(NULL));//乱数初期化
	my_srand(10,14);//MY乱数初期化。10～14の数値を設定する
	printf("%d\n",my_rand(&error_flag));//10～14のどれかが表示される
	printf("%d\n",my_rand(&error_flag));//10～14のどれかが表示される
	printf("%d\n",my_rand(&error_flag));//10～14のどれかが表示される
	printf("%d\n",my_rand(&error_flag));//10～14のどれかが表示される
	printf("%d\n",my_rand(&error_flag));//10～14のどれかが表示される
	printf("%d\n",my_rand(&error_flag));//エラー(上で5個しかセットしてないので)
	printf("%d\n",my_rand(&error_flag));//エラー(この時error_flagには-1が入っている)
	delete_my_rand();//MY乱数消去
	return 0;
}

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

実行結果

10
11
14
13
12
0
0

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

こういう使い方が適切かどうかわかりませんが、
何か参考になればどうぞ＾＾；

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "my_rand.h"

int main(void){
	int error_flag;
	srand((unsigned)time(NULL));//乱数初期化
	my_srand(10,14);//MY乱数初期化。10～14の数値を設定する
	printf("%d\n",my_rand(&error_flag));//10～14のどれかが表示される
	delete_my_rand();//MY乱数消去
	return 0;
}

う、お返事遅くなってすみません。リナックスでしたか。
先ほどいった様に、少しずつ作っていってはどうですか？

とりあえずサンプルは動くんですよね？
それなら、とりあえずサンプルをそのまんま貼り付けて作っていけばどうでしょう？

int main(void){

	int error_flag;

	srand((unsigned)time(NULL));//乱数初期化

	my_srand(10,14);//MY乱数初期化。10～14の数値を設定する

	[color=#00ffff>//ここでmy_rand(&error_flag)を使う[/color]

	delete_my_rand();//MY乱数消去

	return 0;

}

その「ここで」の部分で使ってます？乱数消した後で使ったりしてません？
どうしても解決しないならソース丸ごとこちらに投稿してもらうほかなさそうです。

#include <cstdlib>
#include <vector>

class CRandom
{
private:
	std::vector<int> m_data;
	unsigned int m_max;
	unsigned int m_count;

public:
	CRandom(unsigned int max, unsigned int seed)
	{
		// 初期化
		m_max = 0;
		m_count = 0;
		m_data.clear();
		SetMaxValue(max);
		Srand(seed);
	}

	virtual ~CRandom(void)
	{
		// 念の為に破棄する
		m_data.clear();
	}

	void Srand(unsigned int seed)
	{
		srand(seed);
	}

	bool SetMaxValue(unsigned int max)
	{
		if (max > INT_MAX || max == 0)
		{
			// int型の最大値よりも大きい値、もしくは０が入力された場合はfalseを返す
			return false;
		}
		else
		{
			// メンバ変数の初期化
			m_count = 0;
			m_max = max;
			m_data.clear();
			m_data.resize((std::vector<int>::size_type)max);

			// データバッファを初期化
			for (unsigned int i = 0; i < m_max; ++i)
			{
				m_data = i;
			}

			// データバッファをシャッフル
			for (unsigned int i = 0; i < m_max - 1; ++i)
			{
				int id = rand() % (m_max - 1);
				int swap = m_data[id];
				m_data[id] = m_data[m_max - 1];
				m_data[m_max - 1] = swap;
			}

			return true;
		}
	}

	int Rand()
	{
		// サイズが０の場合は常に０を返す
		if (m_max == 0)
		{
			return 0;
		}

		// 乱数が一巡した場合はリセットする
		if (m_count >= m_max)
		{
			SetMaxValue(m_max);
		}

		// 乱数を返しつつ、カウントを進める
		return m_data[m_count++];
	}
};

#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>

class CRandom
{
public:
	CRandom()
	{
	}

    int operator()(int max) const
    {
		double data = static_cast<double>(std::rand()) / static_cast<double>(RAND_MAX);
		return static_cast<unsigned int>(data * max);
    }
};


class CShuffle
{
private:
	std::vector<int> m_data;
	size_t m_count;

public:
	CShuffle(size_t max, unsigned int seed)
	{
		m_count = 0;
		m_data.clear();
		Srand(seed);
		SetMax(max);
	}

	virtual ~CShuffle(void)
	{
		m_data.clear();
	}

	void Srand(unsigned int seed)
	{
		std::srand(seed);
	}

	bool SetMax(size_t max)
	{
		if (max > RAND_MAX || max > INT_MAX || max == 0)
		{
			return false;
		}
		else
		{
			m_count = 0;
			m_data.clear();
			m_data.resize(max);

			for (int i = 0; i < static_cast<int>(m_data.size()); ++i)
			{
				m_data = i;
			}

			CRandom random;
			std::random_shuffle(m_data.begin(), m_data.end(), random);
			return true;
		}
	}

	int GetValue()
	{
		if (m_data.size() == 0)
		{
			return 0;
		}

		if (m_count >= m_data.size())
		{
			SetMax(m_data.size());
		}

		return m_data[m_count++];
	}
};

class CRandom
{
public:
	CRandom()
	{
	}

	int operator()(int max) const
	{
		double data = static_cast<double>(std::rand()) / static_cast<double>(RAND_MAX);
		return static_cast<unsigned int>(data * max);
	}
};

class CRandom
{
public:
	CRandom()
	{
	}

	int operator()(int max) const
	{
		double data = static_cast<double>(std::rand()) / static_cast<double>(RAND_MAX);
		return static_cast<int>(data * max);
	}
};

#include <stdio.h>

int main()
{
    int a = 10;

    printf("a = %08X\n~a = %08X\n", a, -a);

    return 0;
}

printf("a = %08X\n~a = %08X\n", a, -a);
　　　　　　　　　　　　　　　　//↑ここの部分。