Brøkregning

Ups nu skulle jeg lige til at skrive, at jeg ingen hjælp vil have foreløbig, da jeg selv lige ville kigge på det mere grundigt nu her iaften. Men så kan jeg vel bruge tiden på at lave det sidste om i main, som du også skriver. Jeg vender tilbage hvis jeg har nogle spørgsmål. Ellers tusind tak for den foreløbig hjælp, det er så rart at man kan få noget hjælp, så hurtigt herinde

Også tak til jer andre.

Okay, nu har jeg læst om funktionen friend, og jeg er stadigvæk lidt i tvivl om hvordan den bruges. Jeg er med på at ved brug af friend funktionen kan man få adgang til class'ens private members.

Jeg har så fundet følgende opgave her på nettet:

"Make the bark( ) function of the dog class a friend of the cat class, and the meow ( )
function a friend of the dog class."

dvs. funktionerne bark () og meow skal kunne hver modtage noget fra hinanden. Lad os sige at outputtet skal være følgende:

woof woof woof woof woof <= Ofelia barks at Fie
meow meow meow meow <= Fie meows at Ofelia

hvordan starter jeg??

Her er én måde at løse det på:

#include <iostream>

class CatBase
{
   friend class Dog;
   virtual void Meow() = 0;
};

class Dog
{
   friend class Cat;
   friend class CatBase;
   void Bark() { std::cout << "Dog Barking" << std::endl; }
public:
   void Do(class CatBase& _cat) { _cat.Meow(); }
};

class Cat : public CatBase
{
   void Meow() {  std::cout << "Cat Meowing" << std::endl; }
public:
   void Do(Dog& _dog) { _dog.Bark(); } // Cat makes the dog bark
};

int main()
{
   Dog dog;
   Cat cat;
   dog.Do(cat);
   cat.Do(dog);
}

Det er måske lidt forvirrende, da der er tale om cirkulære afhængigheder, nedarvning og virtuelle funktioner.

Jeg fortår ikke:
woof woof woof woof woof <= Ofelia barks at Fie
meow meow meow meow <= Fie meows at Ofelia

UHA. Det må du lige forklare nærmere om. Først vil jeg lige høre hvorfor du opretter klassen Catbase???

Dog afhænger af Cat, Cat afhænger af Dog, det kaldes en cirkulær afhængighed. CatBase var en måde at løse det på ved at lave en base class til en af classerne.

Man kan også gøre det uden, det er lidt enklere:

#include <iostream>

class Dog
{
   friend class Cat;
   void Bark() { std::cout << "Dog Barking" << std::endl; }
public:
   void Do(class Cat& _cat);
};

class Cat
{
   void Meow() {  std::cout << "Cat Meowing" << std::endl; }
   friend class Dog;
public:
   void Do(Dog& _dog) { _dog.Bark(); } // Cat makes the dog bark
};

void Dog::Do(class Cat& _cat)
{
   _cat.Meow(); // Dog Makes the cat Meow
}

int main()
{
   Dog dog;
   Cat cat;
   dog.Do(cat);
   cat.Do(dog);
}

Okay, men synes kode nr. 2 er meget lettere at forstå

Nu sad jeg og tænkte på hvad med hvis man også skal gøre programmet afhængig af følgende:

1) A dog barks at a cat exactly the number of times as the length of the cat's name.

2) A cat meows at a dog exactly the number of times as the length of the dog's name.

Det vil sige output skal se sådan ud, hvis nu fx. at hunden hedder Ofelia og katten Fie.

woof woof woof

meow meow meow meow meow meow

Hvis jeg ikke tager fejl må der her bruges arrays og loops, ik?:

#include <iostream>
using namespace std;

class Dog
{
   friend class Cat;
   void Bark() { cout << "meow meow meow meow" << endl; }
public:
   void Do(class Cat& _cat);
};

class Cat
{
   void Meow() { cout << "woof woof woof woof woof" << endl; }
   friend class Dog;
public:
   void Do(Dog& _dog) { _dog.Bark(); } // Cat makes the dog bark
};

void Dog::Do(class Cat& _cat)
{
   _cat.Meow(); // Dog Makes the cat Meow
}

int main()
{
   Dog dog;
   Cat cat;
   dog.Do(cat);
   cat.Do(dog);
}

Start med at give dyrene navne. Dvs. Cat og Dog skal have en variabel til at indeholde navnet, en std::string synes at være velegnet dertil.

Cat skal have en metode til at kende lænden på Dog's navn (og omvendt), det letteste er at gøre variablen med navnet public.

Så skal du lave en for loop i Meow() og Bark() der skriver "woof" eller "meow" det rette antal gange.

Prøv at lave det, spørg hvis du løber ind i problemer.

Tusind tak for din "to-do list". Det er altid rart når man har noget at få ud fra. Jeg har prøvet at lave de to første ting du nævner, men programmet bliver ved med at komme med en fejl omkring den funktion der skal kende længden på dogs og cats navne. Er jeg helt galt på den:

#include <iostream>
#include <string>

using namespace std;

class Dog
{
   char* Dog;
   friend class Cat;
   void Bark() { cout << "meow meow meow" << endl; }
public:
   void Do(class Cat& _cat);
   Dog::Cat&_cat(char *Dog)
   {
   Cat = new char[strlen(dog)];
   }
};

class Cat
{
   char* Cat;
   void Meow() { cout << "woof woof woof woof woof" << endl; }
   friend class Dog;
public:
   void Do(Dog& _dog) { _dog.Bark(); } // Cat makes the dog bark
   Cat::Dog&_dog(char *Cat)
      {
      Dog = new char[strlen(cat)];
      }
};

void Dog::Do(class Cat& _cat)
{
   _cat.Meow(); // Dog Makes the cat Meow
}

int main()
{
   Dog dog;
   Cat cat;
   dog.Do(cat);
   cat.Do(dog);
}

Først skal vi kikke lidt på hvad en constructor er. Det er en funktion i en class der har samme navn som class'en og som ikke returnerer noget.

class'en Dog med en default constructor (dvs. en constructor uden parametre) kan se sådan ud:
class Dog
{
public:
Dog()
{
cout << "Dog default contructor" << endl;
}
};

Vi vil nu lave en contstuctor i stedet der tager hundens navn som parameter. Du har valgt at bruge char*, så den kunne se sådan ud:
class Dog
{
public:
Dog(const char* _name)
{
cout << "Dog name: "<< _name << endl;
}
};

Det næste er at vi skal gemme navnet på hunden i class'en, det er du begyndt på, men der mangler lidt, det kan se sådan ud:
Dog(const char *_name)
{
name = new char[strlen(name) + 1];
strcpy(name, _name);
}
Her er name en variabel til at holde navnet på hunden. Du har kaldt den Dog, men jeg synes at name er mere logisk.

Når man kalder new skal man også kalde delete, i vores tilfælde er det mest praktisk at gøre det i class'ens destructor, den kommer til at se sådan ud:
~Dog()
{
delete [] name;
}

Prøv at putte ovenstående ind i din kode, og lav det samme for Cat

Så burde de to class'er kende længden på den andens navn, og kan bruge det til i Bark() og Meow()

Jeg tror det ville være lettere at bruge std::string i stedet for char* til at holde dyrenes navne, men det vælger du.

Tak for det. Jeg har stadigvæk problemer med at få koden til at køre. hvad gør jeg galt:

#include <iostream>
#include <string>

using namespace std;

class Dog
{
   std::string name;
   friend class Cat;
   void Bark() { cout << "meow meow meow" << endl; }

public:
	void Do(class Cat& _cat);

	Dog(std::string _name)
	{
	cout << "Dog name: "<< _name << endl;
	
	name = new std::string[strlen(name) + 1];
	strcpy(name, _name);
	}
};

~Dog()
{
delete [] name;
};


class Cat
{
   std::string Cat;
   friend class Dog;
   void Meow() { cout << "woof woof woof woof woof" << endl; }

public:
   void Do(Dog& _dog) { _dog.Bark(); } // Cat makes the dog bark

   Cat(std::string _name)
   	{
   	cout << "Cat name: "<< _name << endl;
   	name = new std::string[strlen(name) + 1];
   	strcpy(name, _name);
   	}
};

~Cat()
{
delete [] name;
};

void Dog::Do(class Cat& _cat)
{
   _cat.Meow(); // Dog Makes the cat Meow
};

int main()
{
   Dog dog;
   Cat cat;
   dog.Do(cat);
   cat.Do(dog);
}