Kopírovací konstruktor – C / C++ – Fórum – Programujte.com

Co dělám špatně že dostávám tuto hlášku?

'MyDFT' : no appropriate default constructor available

 hlavička:

class MyDFT {
    private:
        int file_no;
        int width;
        int height;
        cv::Mat Images[2]; // up to two images
        cv::Mat padded;
        cv::Mat channels;
        cv::Mat complex;
    public:
        int getSpectrum(const char * file, int flag);
        MyDFT(const char * file, int flag);
};

cpp: - definice konstruktoru

MyDFT::MyDFT(const char * file, int flag) : file_no(-1),width(0), height(0) {
}

main.cpp

MyDFT myDFT;

#1 oxidián
MyDFT myDFT;  se snazi volat konstruktor bez parametru: MyDFT() { ...

Ten tam opravdu nemas.

Ok, dík. A ještě jeden problém:

MyDFT myDFT();

myDFT.getSpectrum(filename, IMREAD_GRAYSCALE);

myDFT.getSpectrum(subimage, IMREAD_GRAYSCALE);

mi píše

error C2228: left of '.getSpectrum' must have class/struct/union

Když zakomentuju ty dva řádky a pozastavím kód hned za MyDFT myDFT(); a přidám kukátko myDFT tak tam mám chybu chybný symbol myDFT

Ještě jsem zkoušel:

MyDFT::MyDFT(void) : file_no(-1),width(0), height(0) {}

to hlásí tu samou chybu

#3 oxidián
minimalne bys mel mit: 

MyDFT::MyDFT() : file_no(-1),width(0), height(0) {}

Dale pak:

MyDFT myDFT;

Kazdopadne visual studio jsem nepouzival od vejsky, takze netusim, co by se mu na tom nemuselo libit. Google na tu chybu C2228 zminoval jen ze se musi objekt definovat bez zavorek (ten myDFT, neni myslena trida):

MyDFT myDFT(); // je jen prototyp funkce bez parametru vracejici MyDFT objekt...

 Neco takoveho se treba v g++ zkompiluje (cv:: jen nemam, tak je zakomentovane a getSpectrum jen vraci flag):

class MyDFT {
    private:
        int file_no;
        int width;
        int height;
        //cv::Mat Images[2]; // up to two images
        //cv::Mat padded;
        //cv::Mat channels;
        //cv::Mat complex;
    public:
        int getSpectrum(const char * file, int flag);
        MyDFT(const char * file, int flag);
        MyDFT();
};

MyDFT::MyDFT(const char * file, int flag) : file_no(-1),width(0), height(0) {
}

MyDFT::MyDFT() : file_no(-1),width(0), height(0) {
}

int MyDFT::getSpectrum(const char * file, int flag) { return flag; }

int main() {
    MyDFT  myDFT;

    myDFT.getSpectrum(nullptr,0);
    
}

Ok dík. Někde jsem viděl že se do prázdných závorek dává void:

void foo(void);

je to zbytečnost?

nevíš proč?

V C++ urcite zbytecnost, pouzivalo se to drive v C, ale tusim, ze to uz taky davno neni problem (mozna jen zpetna kompatibilita s nejakejma ultra starejma prekladacema).

EDIT:

Si muzes pocist: http://stackoverflow.com/questions/693788/is-it-better-to-use-c-void-arguments-void-foovoid-or-not-void-foo

Udajne to ma v C trosku specialnejsi vyznam

Ještě řeším jeden problém - nejde mi tento příkaz

static void write(cv::FileStorage& fs, const std::string&, const MyData& x)

Vygeneruje to chyby:

C4430: missing type specifier - int assumed. Note: C++ does not support default-int
C2143: syntax error : missing ',' before '&'
C2065: 'x' : undeclared identifier
C2228: left of '.write' must have class/struct/union

V headeru nic není a cpp je toto:

#include "mydata_class.h"

using namespace std;
using namespace cv;

class MyData
{
	public: // Data Members
		int A;
		double X;
		string id;

		// Copy constructor
		MyData() : A(0), X(0), id() {}
	// explicit to avoid implicit conversion
	explicit MyData(int) : 
		A(97), X(CV_PI), id("mydata1234") {}
	
	// Write serialization for this class
	void write(cv::FileStorage& fs) const 
	{
	fs << "{" << "A" << A << "X" << X << "id" << id << "}";
	}
	void read(const cv::FileNode& node) //Read serialization for this class
	{
	A = (int) node["A"];
	X = (double) node["X"];
	id = (string) node["id"];
	}
};

A teď si říkám, že header má deklarovat a cpp definovat. Takže je to špatně, protože deklaruju tu třídu 2x.

Ale není mi jasné jak přezapsat toto:

MyData() : A(0), X(0), id() {}
// explicit to avoid implicit conversion
explicit MyData(int) :
        A(97), X(CV_PI), id("mydata1234") {}

Mám to přesunout do headeru nebo psát definici takto?

MyData::MyData() : A(0), X(0), id() {}

MyData::MyData(int) : A(97), X(CV_PI), id("mydata1234") {}

Nově to mám takto (soubor cpp)

#include "mydata_class.h"

using namespace std;
using namespace cv;

MyData::MyData() : A(0), X(0), id() {}
	// explicit to avoid implicit conversion
	// explicit 
	MyData::MyData(int) : 
		A(97), X(CV_PI), id("mydata1234") {};
};

// Write serialization for this class
MyData::write(cv::FileStorage& fs) const 
{
	fs << "{" << "A" << A << "X" << X << "id" << id << "}";
}
// Read serialization for this class
MyData::read(const cv::FileNode& node)
{
	A = (int) node["A"];
	X = (double) node["X"];
	id = (string) node["id"];
}

mydata_class.cpp
mydata_class.cpp(11): error C2059: syntax error : '}'
mydata_class.cpp(11): error C2143: syntax error : missing ';' before '}'
mydata_class.cpp(11): error C2059: syntax error : '}'
mydata_class.cpp(15): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
mydata_class.cpp(15): error C2556: 'int MyData::write(cv::FileStorage &) const' : overloaded function differs only by return type from 'void MyData::write(cv::FileStorage &) const'
mydata_class.h(18) : see declaration of 'MyData::write'
mydata_class.cpp(15): error C2371: 'MyData::write' : redefinition; different basic types
mydata_class.h(18) : see declaration of 'MyData::write'
mydata_class.cpp(20): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
 

No kazdopadne   MyData()   neni kopirovaci konstruktor (pro upresneni terminologie)

A zmen ten paskvil na:

MyData::MyData() : A(0), X(0), id() {}

MyData::MyData(int) : A(97), X(CV_PI), id("mydata1234") {}

 Puvodne tam mas totiz neco takoveho (po procisteni odsazeni a komentaru):

MyData::MyData() : A(0), X(0), id()
{
}

MyData::MyData(int) : A(97), X(CV_PI), id("mydata1234")
{
};
};

No to jsem udělal + to na konci tam nemá být

//};

Ale stále mi to vrací chybu za slovem const. Na řádku s {

missing type specifier - int assumed. Note: C++ does not support default-int

Teď to je takto:

#include "mydata_class.h"

using namespace std;
using namespace cv;

MyData::MyData() : A(0), X(0), id() {}
	// explicit to avoid implicit conversion
	// explicit 
	MyData::MyData(int) : 
		A(97), X(CV_PI), id("mydata1234") {};
//};

// Write serialization for this class
MyData::write(cv::FileStorage& fs) const 
{
	fs << "{" << "A" << A << "X" << X << "id" << id << "}";
}
// Read serialization for this class
MyData::read(const cv::FileNode& node)
{
	A = (int) node["A"];
	X = (double) node["X"];
	id = (string) node["id"];
}

header:

class MyData
{
	public: // Data Members
		int A;
		double X;
		std::string id;

		MyData() ;
		explicit MyData(int);
	
	void write(cv::FileStorage& fs) const;
	void read(const cv::FileNode& node);
};

Mimoto co vlastně znamená deklarace: explicit MyData(int); ?

 No ta chyba je jasna:

// prototyp mas:

	void         write(cv::FileStorage& fs) const;

// definujes:
             MyData::write(cv::FileStorage& fs) const

explicit znamena, ze ti nebude implicitne prevadet int (nebo jiny typ) na tu tridu treba pokud je ocekavana v parametrech.

class Trida1 {
  public:
    Trida1(int i) : t{i} {}
    int  t;
};

class Trida2 {
  public:
    explicit Trida2(int i) : t{i} {}
    int  t;
};

//mas funkce:
int funkce1(Trida1 t) { return t.t; }
int funkce2(Trida2 t) { return t.t; }

// a pokud je zavolas takto:
funkce1(1); // tady to projde - implicitne prevede 1 na Trida1

funkce2(2); // a tady to selze, implicitni prevod je zakazany

funkce2(Trida2{2}); // musi se specifikovat trida - toto projde

nemohl bys to říct jednodušeji a víc česky? nerozumím ničemu.

Vůbec nechápu co to jsou

Implicit conversions, explicit conversions a contextual conversions.

To se vysvetluje blbe, musis znat vyznam slov implicitni a explicitni..  Implicitni prevod je ve smylu automaticky, pokud to jde (napriklad int8_t jde priradit do int32_t a tak, nebo do objektu, pokud ma takovy konstruktor bez explicit).

Explicitni prevod musis "rici" prekladaci, ze si jses opravdu jist, ze to tak chces (vetsinou static_cast<na_typ>(z_typu), reinterpret_cast (u nej je to nejdulezitejsi, muzes udelat doslova "z komara velblouda" a tak dale... 

Explicitní jako že mu vše musím polopatě vysvětlit...

Implicitní že si to tam stroj/progam zvládne dosadit sám na základě předem určených pravidel... jako když nastavíž argumenty ve funkci na int k = 1, int p = 2 atd...

To se mi bude těžko pamatovat.. Škoda, že to není imbecilní, to by se lépe pamatovalo jako že je imbecilní a nezvládne si to tam automaticky dosadit, ale je to právě naopak...

Přepisuji třídu.

Původně:

class MyData
{
public:
MyData() : A(0), X(0), id()
{}
explicit MyData(int) : A(97), X(CV_PI), id("mydata1234") // explicit to avoid implicit conversion
{}
void write(FileStorage& fs) const //Write serialization for this class
{
fs << "{" << "A" << A << "X" << X << "id" << id << "}";
}
...
}

Přepsal jsem to takto (deklarace):

class MyData
{
  public: MyData() ;
  explicit MyData(int);	
  void write(cv::FileStorage& fs) const;
};

změnil se tím význam?

Toto do deklarace dát nemůžu:

explicit MyData(int):(97), X(CV_PI), id("mydata1234");

to by v tom byla definice a hodí to chybu.

Vyznam to zmeni - uplne si zazdil  public:

(A mozna i ty tridni promenne? Nebo si je jen vynechal)

to jsem vynechal abych zkrátil kód

kazdopadne nezapomen poradne formatovat a odsazovat kod, jsem tam ten public uplne prehledl

#20 KIIV
ne, já to opravil :-) ha ha

ale z tvé odpovědi nevím jak mám napsat tu deklaraci. Nemám tam strkat to

A(97), X(CV_PI), id("mydata1234") {};

to přece nemá být v deklaraci

No prostě nevím jak mám toto přepsat do dvou souborů .h a .cpp:

class MyData
{
public:
MyData() : A(0), X(0), id()
{}
explicit MyData(int) : A(97), X(CV_PI), id("mydata1234") // explicit to avoid implicit conversion
{}
void write(FileStorage& fs) const //Write serialization for this class
{
fs << "{" << "A" << A << "X" << X << "id" << id << "}";
}
void read(const FileNode& node) //Read serialization for this class
{
A = (int)node["A"];
X = (double)node["X"];
id = (string)node["id"];
}
public: // Data Members
int A;
double X;
string id;
};

Původní kód má sloužit buď k zápisu do xml souboru nebo ke čtení. Chápu to tak,

že pokud čteš použiješ

MyData m;

a MyData.id se nastaví až při čtení struktury na id = (string) node["id"];

Pokud zapisuješ do xml souboru tak použiješ
MyData m(1);

a tím se id nastaví na přednastavenou hodnotu "mydata1234".

Mám to tedy teď takto:

MyData::MyData() : A(0), X(0), id() {} // pro čtení
MyData::MyData(int) :
        A(97), X(CV_PI), id("mydata1234") {}; // pro zápis

A stále stejná chyba.

Konečně jsem to vyřešil. Tak celou dobu jsem se díval na nesprávné místo. Problém nebyl v konstruktoru a se slovem explicit, ale přímo v té funkci write. Jinými slovy mi to říkalo, že tam nemám deklarovaný return type. A já už prostě zapoměl, že to void patří nejen do deklarace, ale taky k té implementaci...

#24 oxidián
no to jsem ti naznacoval uz davno :D

naznačovat nestačí

Beztak je lepsi, ze sis to nasel sam. Ted to snad nezapomenes :D Narozdil od varianty ze bych ti to rekl primo...

Napriklad toto zapomenes urcite rychle:  Pokud budes toto rozdelovani aplikovat na sablony, narazis nevyhnutelne na "undefined symbol". U sablon se musi includovat vse (nebo to mit predkompilovane pro urcite vytipovane typy).

Já hlavně potřebuju pořád s tím C/C++ pracovat. To chce aspoň tři měsíce v kuse abych si to zapamatoval. Anebo třeba 14 dní C/C++ a 14 dní pauza. A tak to opakovat víckrát za sebou.