Anonymní profil Jurin – Programujte.com

#30 Staon
Ale vaše první ukázka kódu měla vadu, že proces A skončil ihned poté, co se aplikace B spustila (ihned po prvním úspěšném otevření roury, funkce exit ukončuje celý proces, ne jen vlákno). Jste si jistý, že tam něco takového nemáte?

Ale to je přesně to co bych potřeboval. Bohužel to nefunguje a aplikace A se neukončí, protože funkce exit se nikdy nezavolá. Funkce open vždy skončí s chybou -1 a errno je nastaveno na hodnotu 2.

Toto jsem zjistil:

Pustím aplikaci A, která vypisuje pořád něco na display. Aplikace A si vytvoří další vlákno ve kterém čeká až bude vytvořená roura "myfifo". Až bude tato roura vytvořená aplikace A se ukončí.

Pustím aplikaci B, která vytvoří rouru "myfifo" a skončí.

Aplikace A na to bohužel nereaguje a proto aplikaci A ukončím ručně (na kostce zmáčknu tlačítko Esc a na to aplikace A reaguje tak, že se ukončí)

Znovu spouštím aplikaci A, která se ihned ukončí protože už najednou vidí vytvořenou rouru "myfifo".

Proč tu rouru nevidí hned, proč musím nejdřívé aplikaci A ukončit a potom znovu spustit aby rouru viděl?

#28 Staon
Procesy běží určitě najednou. Aplikaci A můžu ukončit pouze ručně a pořád v cyklu mi vypisuje něco na display kostky. Když spouštím aplikaci B, tak aplikace A pořád vypisuje na display.

Neznám Linux, takže nevím co znamená, že každý proces běží v jiném terminálu.

Díval jsem se na parametry příkazu ps, ale když použiji ps aux nebo ps -ef nebo cokoliv jiného tak mi to do výstupu napíše, že tyto parametry nezná. Jediný parametr který mi projde je -w.

Zkoušel jsem i z aplikace B spustit příkaz kill s PID aplikace A.

Napíše mi to chybu, že takové PID neexistuje.

Co se týká FIFO zkoušel jsem i postup jaký popisuješ. Aplikace A vytvoří rouru, aplikace B si ji potom otevře a zapíše do ní. To funguje, ale aplikace A vůbec nevidí data, která tam aplikace B zapsala. Takže v aplikaci A nepoznám, že aplikace B už něco zapsala.

Pořád mi to připadá, že nemám dostačné práva na tyto akce.

Ale Linux neznám, tak nevím jak zjistit jaká mám práva.

typedef std::vector<std::string>			T_RowString;
typedef std::vector<T_RowString>			T_TableString;

bool CSV_Read(const std::string &inFileName,char inSeparator,T_TableString &outTable)
{
	using namespace std;

	outTable.clear();

	ifstream file(inFileName.c_str());
	while (file.good())
	{
		string sLine;
		getline(file,sLine);

		std::istringstream lineStream(sLine);

		T_RowString row;
		string sCell;
		while ( getline(lineStream,sCell,inSeparator) )
			row.push_back(sCell);

		if ( !row.empty() )
			outTable.push_back(row);
	}

	return true;
}

vitamin:

Tvůj příklad je jasný, mě celou dobu mátl MS překladač kde prochází tento kod. 

struct Test
{
	Test()
	{
		std::cout << "Test::Test()\n";
	}

	Test(Test&)
	{
		std::cout << "Test::Test(Test&)\n";
	}


	~Test()
	{
		std::cout << "Test::~Test()\n";
	}
};

int main()
{
	{
		Test B = Test();
	}

	return 0;
}

Díky všem za příspěvky.

Stejně mě to furt nějak neleze do hlavy.

Když tento CTOR  XXX(MyRef inRight)  ze třídy XXX vyhodím, tak se to chová jak bych čekal, tj. volá se jenom CTOR  XXX(int* const Ptr). A copy CTOR mám pořád stejně, bez const.

Když CTOR  XXX(MyRef inRight)  přidám do XXX, tak se pro mě z nějakého záhadného důvodu začne volat.

Chová se to stejně v gcc i MS VS 2010.

Já myslel, že u tohoto volání  

return XXX(new int);

je dáno standartem C++, že copy CTOR se nevolá.

pro KIIV.

Nemusí, ale vetšinou by měl.

Toto je čístě z teoretických důvodů, proč se to takto volá. Nějak mi to nedává smysl.

Dík, ale v tomto případě by se copy CTOR vůbec neměl volat.

Pokud dám copy CTOR jako const referenci, tak to funguje jak má a volá se pouze tento CTOR 

XXX(int* const Ptr = 0) a copy CTOR se vůbec nevolá.

Mám tento kod

struct MyRef
{
	explicit MyRef(int* inRight) : 
		m_Ref(inRight)
{
}

	int* m_Ref;
};

class XXX
{
public:
	XXX(int* const Ptr = 0):
		m_Val(Ptr)
	{
		cout << "XXX::CTOR(int*)" << endl;
	}

	XXX(XXX &inRight):
		m_Val(inRight.m_Val)
  	{
		cout << "XXX::CTOR(XXX&)" << endl;
  	}

	XXX(MyRef inRight):
		m_Val(inRight.m_Ref)
  	{
		cout << "XXX::CTOR(MyRef)" << endl;
  	}

  	operator MyRef()
  	{
		cout << "operator MyRef" << endl;

	  	MyRef ret(m_Val);
	  	m_Val = 0;
	  	return ret;
  	}

  	~XXX()
  	{
		cout << "XXX::DTOR() " << m_Val << endl;
	  	delete m_Val;
  	}

private:
	int* m_Val;
};

XXX MyCreate()
{
	return XXX(new int);
}

int main()
{
	XXX a = MyCreate();

	return 0;
}

Proč se při volání funkce MyCreate volá konstructor XXX(MyRef inRight) a tím pádem operátor přetypování operator MyRef() ?

Děkuji.