Здравствуйте, Балакин Артем Петрович!
Вот вариант решения Вашей задачи с динамической памятью. Кости хранятся в динамическом массиве целых чисел, значения генерируются через rand. Сам код класса в приложении, а вот пример того, как его вызывать:


Тут особо и не о чем рассказывать, класс простой.
Проверено в VS 2010, с 2005 различий не будет. Будут вопросы, задавайте.
Удачи!

Приложение:
//CBones.h
#pragma once
#include <iostream>
using namespace std;

class CBones
{
int *bones; //кости
int count; //количество

public:
CBones(); //конструктор по умолчанию
CBones (int n); //конструктор из массива
CBones (int* elem, int n); //конструктор из массива
CBones (const CBones &t); //конструктор копирования
~CBones(); //деструктор

CBones& operator= (const CBones t); //оператор присваивания

CBones& operator+= (const int t);
CBones& operator-= (const int t);

int operator[] (int key); //получение

void Shuffle (); //перемешать
int Result (); //сумма
bool HasResult (int res); //поиск результата

friend ostream& operator << (ostream& str, CBones& t); //вывод
};


//CBones.cpp
#include "StdAfx.h"
#include "CBones.h"
#include <time.h>

CBones::CBones()
{
bones = NULL;
count = 0;
srand (time(NULL)); //инициализируем генератор случайных чисел
}

CBones::CBones (int n)
{
srand (time(NULL));
count = n;
bones = new int [n]; //выделяем память
for (int i = 0; i<count; i++)
bones[i] = rand()%6 + 1; //заполняем значениями от 1 до 6
}

CBones::CBones (int* elem, int n)
{
srand (time(NULL));
count = n;
bones = new int [n];
memcpy (bones, elem, sizeof(int)*count); //копируем массив
}

CBones::CBones (const CBones &t)
{
srand (time(NULL));
count = t.count; //копируем все данные из исходного
bones = new int [count];
memcpy (bones, t.bones, sizeof(int)*count);
}

CBones::~CBones()
{
if (bones!=NULL) delete [] bones; //если массив не пуст, удаляем
}

CBones& CBones::operator= (const CBones t)
{
count = t.count; //аналогично конструктору копирования
if (bones!=NULL) delete [] bones; //только надо удалить, если что-то есть уже
bones = new int [count];
memcpy (bones, t.bones, sizeof(int)*count);
return *this;
}

CBones& CBones::operator+= (const int t)
{
int* tmp = new int [count+1]; //новый массив
if (bones!=NULL) { //копируем старый
memcpy (tmp, bones, sizeof(int)*count);
delete [] bones;
}
tmp[count] = t; //добаляем новое значение
bones = tmp; //переставляем ссылку
count++; //увеличиваем число
return *this;
}

CBones& CBones::operator-= (const int t)
{
if (count==0 || t<1 || t>count) return *this; //если массив пуст или такой кости нет - выходим
int *tmp = new int [count-1]; //новый массив
for (int i=0, j=0; i<count && j<count-1; i++)
if (i!=(t-1)) tmp[j++]=bones[i]; //копируем всё кроме заданной
if (bones!=NULL) delete [] bones; //освобождаем память
bones = tmp; //меняем ссылку
count--; //уменьшаем количество
return *this;
}

int CBones::operator[] (int key)
{
if (count==0 || key<1 || key>count) return -1; //нет такого - возвращаем -1
return bones[key-1]; //есть такой - возвращаем значение
}

void CBones::Shuffle ()
{
for (int i = 0; i<count; i++) //заполняем заново
bones[i] = rand()%6 + 1;
}

int CBones::Result ()
{
int sum = 0; //считаем сумму эл-в массива
for (int i = 0; i<count; i++)
sum+=bones[i];
return sum;
}

bool CBones::HasResult (int res)
{
for (int i = 0; i<count; i++) //ищем результат
if (bones[i] == res) return true;
return false;
}

ostream& operator << (ostream& str, CBones& t) //вывод
{
str << endl;
for (int i=0; i<t.count; i++) { //выводим все элементы, кроме пустых и условно удалённых
char buf [][3] = {{' ', ' ', ' '},{' ', ' ', ' '},{' ', ' ', ' '}}; //пустая кость
switch (t.bones[i]) { //заполняем точками
case 5:
buf[0][2] = '*'; buf[2][0] = '*';
case 3:
buf [0][0] = '*'; buf[2][2] = '*';
case 1:
buf[1][1] = '*';
break;
case 6:
buf[1][0] = '*'; buf[1][2] = '*';
case 4:
buf[0][2] = '*'; buf[2][0] = '*';
case 2:
buf[2][2] = '*'; buf[0][0] = '*';
break;
}
for (int i=0; i<3; i++) { //выводим кость
for (int j=0; j<3; j++)
str << buf[i][j];
str << endl;
}
str << endl;
}
return str;
}