Comment utiliser boost::array avec des inconnus de la taille de l'objet à la variable
J'aimerais utiliser boost::array comme un membre de la classe, mais je ne sais pas la taille au moment de la compilation.
J'ai pensé à quelque chose comme ça, mais il ne fonctionne pas:
int main() {
boost::array<int, 4> array = {{1,2,3,4}};
MyClass obj(array);
}
class MyClass {
private:
boost::array<int, std::size_t> array;
public:
template<std::size_t N> MyClass(boost::array<int, N> array)
: array(array) {};
};
Le compilateur gcc, dit:
error: type/value mismatch at argument 2 in template parameter list for
‘template<class _Tp, long unsigned int _Nm> struct boost::array’
error: expected a constant of type ‘long unsigned int’, got ‘size_t’
Qui signifie évidemment que l'on ne peut pas utiliser de taille variable tableaux en tant que membres de la classe. Si oui, cela irait à l'encontre de tous les avantages de boost::array vecteurs standard ou des tableaux.
Pouvez-vous me montrer ce que je fait de mal?
Vous devez vous connecter pour publier un commentaire.
Du coup de pouce de la matrice est de taille fixe basé sur le second paramètre du modèle, et
boost::array<int,4>
est un différents type de deboost::array<int,2>
. Vous ne pouvez pas avoir des instances de la même classe (MyClass dans votre exemple) qui ont des types différents de leurs membres.Cependant, std::les vecteurs peuvent avoir des tailles différentes sans être de différents types:
Cela dit, boost::array est toujours utile (il est même utile dans cet exemple de code), mais pas dans la manière exacte que vous souhaitez utiliser.
Il vous manque quelques points de base. Vous pouvez avoir:
char arr[10];
char* arr = new arr[10];
Le premier est la taille est connue lors de la compilation (parce que la taille est un constante), d'où vous pouvez pré-allouez un espace de mémoire pour elle, l'autre ne l'est pas, par conséquent, vous devez allouer de la mémoire lors de l'exécution.
STL/TR1/Boost fournit wrappers pour les deux types de tableaux. Ceux qui ne sont pas seulement des wrappers pour convieniece, mais aussi pour la sécurité (contrôle de la portée dans certaines situations) et la puissance (les itérateurs). Dans les deux cas, nous trouvons un wrapper:
boost::array<char,10> arr;
std::vector<char> arr;
Ce dernier a l'avantage d'être auto redimensionnement, et permettant le redimensionnement, en plus d'être dynamiquement affectables.
boost::array
d'autre part, imite untype arr[const]
construire.Par conséquent, vous devez décider si vous voulez que la classe d'avoir de mémoire allouée statiquement ou dynamiquement. L'ancien, n'a de sens que si les classes de stockage est soit de taille fixe, ou de l'une de quelques de dimensions fixes. Ce dernier a de sens que dans tous les autres cas.
Allouée statiquement serait d'utiliser des modèles de
Mais créerait de code distinct pour chaque taille de la classe, et ils ne voulaient pas être inter-opérable (cela peut être contourné si).
Allouée dynamiquement serait d'utiliser des vecteurs
N'ayez pas peur de vecteurs, de les traiter comme des tableaux alloués dynamiquement -- le resizingness de vecteurs est un avantage supplémentaire qui n'affecte pas les performances presque tous.
Puis-je suggérer à l'aide de boost::scoped_array à la place? D'autre part, vous pourriez ne pas vouloir réellement copie l'ensemble du tableau à chaque fois. Puis boost::shared_array serait un meilleur choix.
Non, boost::array (c'est en TR1 comme std::tr1::array) est une manière statique de la taille de la mémoire tampon. Le point de cette classe est d'éviter une allocation dynamique de la mémoire - vous pouvez mettre un boost::array entièrement sur la pile.
Vous pouvez faire votre exemple de la classe de prendre un modèle de type int et le passer à la boost::array membre,
Mais c'est tout juste s'habiller, c'est toujours une allocation statique.
Vous vous trompez sur l'erreur :
Devrait fonctionner. Par la façon dont cela va générer le tableau au moment de la compilation il n'est donc pas une bonne solution. Et d'autres erreurs se produisent.
Ici ce que vous voulez est un vecteur, avec une réserve de taille et de certaines affirmations qui gardent la capacité sur une taille fixe.
boost::array<int, std::size_t>
, et il semble l'interpréter correctement.Si vous avez déjà accepté une réponse, veuillez noter que std::vector peut pas être le bon choix pour votre tâche. Si vous voulez créer le tableau une fois - un tableau de taille fixe - et vous ne voulez pas le redimensionner à la taille plus tard, alors un bon vieux plaine tableau peut être le bon choix pour vous! Ignorer boost::array, ignorer std::vector, ses intentions sont très différents, garder les choses simples. BAISER, YAGNI et ainsi de suite...
EDIT: Que Nikolai N Fetissov déjà dit, boost::scoped_array pourrait être un bon choix. Il fournit une mince RAII wrapper autour de la matrice. Voici un exemple d'utilisation (j'espère que c'est correct, n'hésitez pas à modifier autrement):
Si vous n'avez pas besoin d'un redimensionnement dynamique, vous n'avez pas besoin de std::vector
juste la fonction accept *int
et la passer à l'boost::array 's .de données() pointeur vers les données...
la clé est .de données() les gens!!! Si vous voulez booster les tableaux de remplacer régulièrement les tableaux, c'est peut-être la voie (sans avoir à utiliser des modèles et tout le reste)