addGood(Good* aGood)

 Book:: Book();

 Book book;
         Cart cart;
         cart.add(*book) // this is where I'm confused, the paramter passed

Cart::Cart() : capacity(defaultCapacity), currentWeight(0), goodies () 
{} // goodies is a private vector holding the Good objects
Cart::~Cart() { }
void Cart::addGood (Good* good) {
     goodies.push_back(*good); // plz check if I did wrong with vector:)
}

Good::Good(int weight) : weight(weight) {}
Good::~Good(){ }

 
Book::Book(int weight, std::string name) : Good(weight), name(name) 
{} // the idea is the constructor has a weight and a name paramter

 {Cart mycart;   
          char name[40];   
          // then I read from a input file and get the name string correctly, then see below
          Book mybook(100, *name);// error HERE "invalid conversion from `char' to `const char*' "
     // & another error "initializing argument 1 of `std::basic_string<_CharT, _Traits,  " 
     //(since this is a demonstration, im not sure if the error msg produced here in the original program should be the same for this demonstration or not)
          mycart.addGood(100, *mybook); // error HERE "no match for 'operator*' in '*mybook' "
         }
    

std::string name;

Book mybook(100, name);

void Cart::addGood (Good* good)

mycart.addGood(100, *mybook);

mycart.addGood(*mybook);

void foo(int j)
 {
  j = 0;  /*  modifies the copy of the argument received by the function  */
}

int main(void) {
  int k=10;
  foo(k);
  /*  k still equals 10  */
return 0;
}

void foo(int *j) {
  *j = 0;               //note how the variable is used here.
}

int main(void) {
  int k=10;
  foo(&k);            //note how variable is passed here.
  /*  k now equals 0  */
return 0;
}

Book mybook(100, *name);// error HERE "invalid conversion from `char' to `const char*' "

mycart.addGood(100, *mybook); // error HERE "no match for 'operator*' in '*mybook' "

Book mybook(100, name);           //because name will give the address in the case of char*.

mycart.addGood(100, &mybook);  //pass the reference

using namespace std;
int main()
{
    Cart mycart;
    string name; 
    
    Book mybook(100, &name);           //use &name to pass it by reference. it is different from how you pass a char*
    mycart.addGood(100, &mybook);   //pass the reference of  mybook

    return 0;
}

void foo(int *j) 
{
  *j = 0;       // just want to clearify, if im typing foo(j) in main, Im
                  // actually passing the address of j instead of reference,
                  // right? so this would be wrong against what i wanted (the 
                  // object)
}

int main(void) {
  int k=10;
  foo(&k);    //why &k? shouldn't it pass the reference/pointer
                // instead of the address of k?
                // in this case it seems to me that foo is waiting for an 
                // address parameter. I know im wrong, please correct
                // me. thank you!
  /*  k now equals 0  */
return 0;
}
 

#include "Customer.h"
#include "Rib.h"
#include "Croissant.h"
#include "Jam.h"
#include "Goody.h"

  foo(&k);    //why &k? shouldn't it pass the reference/pointer
                // instead of the address of k?
                // in this case it seems to me that foo is waiting for an 
                // address parameter. I know im wrong, please correct
                // me. thank you!

  *j = 0;       // just want to clearify, if im typing foo(j) in main, Im
                  // actually passing the address of j instead of reference,
                  // right? so this would be wrong against what i wanted (the 
                  // object)

#include<iostream>

class book
{
      public:                                        //public implies that we can use the variables outside the class also
      string book_name;                              //just a variable
      book()                                         //default constructor
      {
            book_name="C++_programming_Language";    //just give a value
      }
};

class good : public book                             //good is the derived class from book
{
      public:
      string good_name;                              //just another string
      good()
      {
            good_name="Book";                        //give it a value in the constructor
      }
};

class cart                                           //class cart
{
      public:
      int items;                                     //number of items
      good* agood;                                   //pointer to your good class
      string cart_name;                              //another string

      cart()
      {
            items=0;                                 //initialize values. items now are zero.
            cart_name="Indian_Airlines";             //give a value to the string.
      }

      void addgood(good* bgood)                      //here is the sample function.
      {
           agood=bgood;                                   //assign your agood member variable to the bgood pointer passed.
           items++;                                          //increase your items by 1
           std::cout<<"One item added to the cart..."<< agood->good_name <<endl;     //this is how you use pointer objects
      }

};

#include"main.h"                //include your main.h

#include<iostream>

int main()
{
    good agood;                 //create objects for good and carts.

    cart carts;

    carts.addgood(&agood);      //this is how you pass values.


    return 0;                   //return 0 indicates successful execution
}