Создать класс "Студент" и классы "Бюджетный студент" и "Коммерческий студент"

class Student {};
 
class CommercialStudent : public Student {};
 
class BudgetStudent : public Student {};

class student {
public:
   int salary();
};
 
class studentb : public student {
public:
   int salary();
};
 
class studentc : public student {
public:
   int salary();
};

#include <iostream>
using namespace std;
 
class student {
protected:
   int st;
public:
   student(){
   st=32;
   cout<<"Всего: "<<st<<endl;
   }
};
 
class studentb : public student {
public:
   studentb(){
       st=11;
       cout<<"Бюджетники: "<<st<<endl;
   }
};
 
class studentc : public student {
public:
   studentc(){
       st=21;
       cout<<"Платники: "<<st<<endl;
   }
};
 
int main(){
    student a;
    studentb b;
    studentc c;
 
    system ("pause");
    return 0;
}

#include <iostream>
#include <sstream>
#include <string>
 
class Student {
 public:
  Student(const std::string &name, size_t course)
    : name_(name), course_(course) {}
  std::string getName() const {
    return name_;
  }
  size_t getCourse() const {
    return course_;
  }
  virtual std::string toString() const {
    std::stringstream result;
    result << "Student: " << getName() << ", course: " << getCourse();
    return result.str();
  }
  friend std::ostream &operator<<(std::ostream &stream, const Student &student){
    return stream << student.toString();
  }
 private:
  std::string name_;
  size_t course_;
};
 
class CommercialStudent : public Student {
 public:
  CommercialStudent(const std::string &name, size_t course, size_t payment)
    : Student(name, course), payment_(payment) {}
  size_t getPayment() const {
    return payment_;
  }
  virtual std::string toString() const {
    std::stringstream result;
    result << "Commercial " << Student::toString() << ", pays: " << getPayment();
    return result.str();
  }
 private:
  size_t payment_;
};
 
class BudgetStudent : public Student {
 public:
  BudgetStudent(const std::string &name, size_t course)
    : Student(name, course) {}
  virtual std::string toString() const {
    std::stringstream result;
    result << "Budget " << Student::toString();
    return result.str();
  }
};
 
int main(int argc, char *argv[]) {
  Student *students[3];
  students[0] = new CommercialStudent("Ivan Ivanov", 3, 25000);
  students[1] = new Student("Petr Petrov", 2);
  students[2] = new BudgetStudent("Petr Petrov", 2);
 
  for (int i = 0; i < 3; ++i) {
    std::cout << *students[i] << std::endl;
    delete students[i];
  }
  return 0;
}

#include <iostream>
#include <sstream>
 
// pure virtual
class StudentInterface {
 public:
  virtual std::string getName() const = 0;
  virtual size_t getCourse() const = 0;
  virtual std::string toString() const = 0;
};
 
// some common realization included
class StudentBase : public StudentInterface {
 public:
  StudentBase(const std::string &name, size_t course)
    : name_(name), course_(course) {}
  virtual std::string getName() const {
    return name_;
  }
  virtual size_t getCourse() const {
    return course_;
  }
 private:
  std::string name_;
  size_t course_;
};
 
// fully qualified
// immutable
class CommercialStudent : public StudentBase {
 public:
  CommercialStudent(const std::string &name, size_t course, size_t payment)
    : StudentBase(name, course), payment_(payment) {}
  virtual size_t getPayment() const {
    return payment_;
  }
  virtual std::string toString() const {
    std::stringstream result;
    result << "Commercial student " << getName() << ", course: " <<
      getCourse() << " pays " << getPayment();
    return result.str();
  }
 private:
  size_t payment_;
};
 
class BudgetStudent : public StudentBase {
 public:
  BudgetStudent(const std::string &name, size_t course, bool isOk)
    : StudentBase(name, course), isOk_(isOk) {}
  virtual bool isOk() const {
    return isOk_;
  }
  virtual std::string toString() const {
    std::stringstream result;
    result << "Budget student " << getName() << ", course: " <<
      getCourse() << ", is " << ((isOk()) ? "ok" : "not ok");
    return result.str();
  }
 private:
  bool isOk_;
};
 
std::ostream &operator<<(std::ostream &stream, const StudentInterface &student) {
  return stream << student.toString();
}
 
int main(int argc, char *argv[]) {
  StudentInterface **students = new StudentInterface*[2];
  students[0] = new CommercialStudent("Ivan Ivanov", 3, 20000);
  students[1] = new BudgetStudent("Petr Petrov", 7, false);
  
  for (int i = 0; i < 2; ++i) {
    std::cout << *students[i] << std::endl;
    delete students[i];
  }
  delete [] students;
  
  return 0;
}