Template et fonction amie / type de retour inconnu

Version imprimable

22/04/2013, 13h22
Armas

Template et fonction amie / type de retour inconnu
Bonjour à tous !

J'ai besoin de vous :) pour un projet de la fac, je dois faire un logiciel de retouche d'image sur le format ppm.

J'ai un soucis au niveau de ma classe image qui est un template : elle contient des fonctions amies et G++ me signal ca comme potentiellement anormale, j'ai un peu peur que lors du teste du programme, tout plante à cause d'une mauvaise declaration de ma part du coup ...

Voici comme j'ai fait :

__________.hpp
Code:

1 2 3 4 5 6 7 8 9 10 11 #include <iostream> template<int N> class image { mes_attribut; public: //fct amie friend void save(image, std::string); };
__________.cpp
Code:

1 2 3 4 5 6 #include <iostream> template<int N> void save(image<N> pic, std::string path) {}
l'erreur est
"friend declaration 'void save(image<N>, str::string)' declares a non-template function"
"if this is not what you intended, make sur the function template has already been declared and add <> after the function name here"

Mon second problème viens du type des images, les images PPM peuvent être des images en noir et blancs (P1) ou couleur(P3), j'ai personnelement choisi de developper une classe "base" qui représente une matrice de nombres, puis image qui est un tableau de N base. Aucun soucis pour ça, SAUF pour le bouton "ouvrir". Bah voui, je sais pas à l'avance si c'est un P1 ou un P3, donc le type de retour de "ouvrir", je le connais pas ...

J'ai vu sur le net qu'on pouvais utiliser comme type de retour, un mot clé "object", mais je n'ai trouvé aucun exemple ... un peu d'aide svp ?

Merci d'avance !! :)

Salut, essaye :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
template <typename N>
class image
{
 
public:
 
	template <typename T>
  friend void save(image<T>, std::string);
};
 
 
template <typename N>
void save(image<N> pic, std::string path)
{}

pour voir.

22/04/2013, 14h03
ternel
Attention, il y a une autre possibilité, qui ne déclare que la fonction prenant la meme template comme friend.
Code:

1 2 3 4 template <typename N> struct image { template <> friend void save(image<N>, std::string); }
j'ai juste un doute sur la syntaxe, entre image<N> ou image?

Citation:

Attention, il y a une autre possibilité, qui ne déclare que la fonction prenant la meme template comme friend.

Bien vu, dans ce cas j'enlèverais effectivement le <N> de image dans la déclaration "interne" de de save car implicite (après peut-être que les deux marche), et par contre je pense qu'il faut mettre

Code:

template <typename>

En gros :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 template <typename N> class image { public: template <typename> friend void save(image, std::string); }; template <typename N> void save(image<N> pic, std::string path) {}
Et si ça ne passe pas, il faut remplacer

Code:

friend void save(image, std::string);

par

Code:

friend void save(image<N>, std::string);

mais là j'avoue que je ne sais pas par cœur.

23/04/2013, 15h04
Armas

Pourquoi un "template <typename>" en fait ? je comprend pas :x

Et vous avez une idée pour mon second problème ? ^^

Ps: l'erreur n'est plus :)
23/04/2013, 15h14
ternel

Je ne pense pas qu'il faille un typename. Sans nom de type derrière, ca me parait … incongru.

Sans "typename" (juste avec "<>") ça marche pas ^^

Et au final, j'ai des plus gros problèmes maintenant ... seg fault ...

Pour représenter mes images, voila comment je fait :

1) une classe "base" (en fait c'est une matrice)
2) un template<int N> "image" qui n'est qu'un tableau de base (un matrice en 3D du coup, pour pouvoir représenter de 1 (si c'est une image noir/blanc) à 3 (pour RGB) "couleurs)).

Je vous montre les parties du codes ou j'ai surement un problème :

MAIN

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include "image.hpp"
#include "base.hpp"
#include <cstdlib>
#include <iostream>
#include <ctime>
#include <cmath>
#include <fstream>
#include <string>
 
int main()
{
	const string load = "./zozo.ppm";
	const string save = "./test2.ppm";
 
	image<3> a(load);
	//a.save(save);
 
	return 0;
}

classe BASE.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
base::base(int lin, int col)
{
	l=lin;
	c=col;
 
	matrice = new int*[lin];
 
	for(int i=0; i<lin; i++)
	{
		matrice[i] = new int[col];
		for(int j=0; j<col; j++)
			matrice[i][j] = 0;
	}
}
 
base::~base()
{
	for(int i=0; i<l; i++)
		delete [] matrice[i];
 
	delete[] matrice;
}
 
 
int* base::operator[](int i)
{
	return matrice[i];
}

classe BASE.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
 
class base
{
	int l, c;
	int** matrice;
 
	public:
		base(int, int);
		~base();
		int* operator[](int);	
};

classe template IMAGE.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
#include <iostream>
#include "base.hpp"
#include <cstdlib>
#include <assert.h>
#include <iostream>
#include <string>
#include <fstream>
 
using namespace std;
 
template <int N>
class image
{
	int line;
	int col;
	int dimension;
	string p;
	int nb_color;
 
	base* img[N];	
 
	public:
		image(string);
                ~image();
		base& operator[](int);
};
 
template <int N>
image<N>::image(string path)
{
	ifstream fichier;
	fichier.open(path.c_str());
 
	if(fichier)
	{
		getline(fichier, p);
 
		fichier >> col;
		fichier >> line;
		dimension = N;
 
		if( ! (p == "P1" || p == "P4"))
			fichier >> nb_color;
		else
			nb_color = 2;
 
		int i, j, k;	
 
		for(i=0; i<N; i++)
			img[i] = new base(line, col);
 
		cout << p << endl << line << endl << col << endl << dimension << endl;
 
		for(j=0; j<line; j++)
		{
			for(k=0; k<col; k++)
			{
				for(i=0; i<N; i++)
				{
					fichier >> *this[i][j][k];
				}
			}
		}
 
		fichier.close();		
	}
}
 
template <int N>
image<N>::~image()
{delete[] img;}
 
 
template <int N>
base& image<N>::operator[](int i)
{
	return *(img[i]);
}

D'après GDB, c'est au niveau de l'operator [], mais je vois pas quoi ... merci d'avance

24/04/2013, 13h09
ternel

Bonjour,

D'abord, deux horreurs, qui rendront to code nocif:
pas de using namespace std;
pas de garde contre les inclusions multiples (#define/#ifndef/code/#endif)

tu inclues tes en-têtes avant les standards, donc ton "using namespace std::" est injecté dedans, posant potentiellement des soucis...

Enfin, un problème de conception: int* matrice::operator[](int).
C'est assez grave pour que nous ayons deux entrées à ce sujet dans la faq:
comment indexer une matrice
pourquoi indexer une matrice avec operator()

Quelque chose me chiffonne avec ton code.
Pourquoi ne parviens-tu pas a avoir une classe de matrice qui soit une valeur.
Je veux dire "Comment ce fait-il que tu sois obligé d'utiliser un tableau de pointeur de matrices?"
24/04/2013, 14h11
germinolegrand

Pour la segfault, c'est tout simple : tu as fais des new et tu fais des delete[], il faut choisir tout l'un ou tout l'autre : new[]+delete[] ou new+delete, mais pas un mix.

Pour le reste +1 leternel.

J'ai déjà des ifndef/endif dans mes .h, je ne les ai pas mit pour alléger un peu ^^ pour le std, je savais pas ... il vaut mieux utiliser systématique std:: alors ?

D'après ce que je lit sur la faq, il faudrai que j'abandonne ma matrice au profit d'un tableau pour suivre ce qui se passe dans la mémoire ?

J'ai changé mon base* img [N]; en base* img;.

je fait un seul new : img = new base[N] puis un delete : delete[] img;.

Je mélange pas, mais j'ai quand même des erreurs :x

ça viens de mon operator=, j'en suis presque sur ! ^^

Operator= d'image
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template<int N> image<N>& image<N>::operator=(image& i) { //je delete l'image pour la réalloué après delete[] img; ... img = new base[i.dimension]; for(int m = 0; m<i.dimension; i++) img[m]=i[m]; }
operator= de base
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 base base::operator=(base& b) { for(int i=0; i<l; i++) delete[] matrice[i]; delete[] matrice; ... matrice = new int*[b.l]; for(int i = 0; i<b.l; i++) matrice[i] = new int[b.c]; }

Dans le constructeur :
Code:

1 2 for(i=0; i<N; i++) img[i] = new base(line, col);
Dans le destructeur :
Code:

1 2 3 template <int N> image<N>::~image() {delete[] img;}

En modifiant en
Code:

1 2 3 4 template <int N> image<N>::~image() {for(int i=0; i<N; i++) delete img[i];}
ça ne marche pas plus :(

24/04/2013, 15h15
germinolegrand

Il faut également changer les new[] de tous tes opérateurs en for+new
24/04/2013, 15h17
Armas

Citation:

Envoyé par germinolegrand

Il faut également changer les new[] de tous tes opérateurs en for+new

Je ne comprend pas ce que tu veux dire :/