Написать класс Student

#include <iostream>
#include <vector>
 
class student{
    public:
        student(){};
        student(std::string _fullname): fullname(_fullname){};
        void setdata();
        bool isgranted() const;
        bool islongX(int assessment) const;
 
    private:
        std::string fullname;
        std::vector<int> assessments;
        int m; //количество экзаменов
        bool grant;
};
 
void student::setdata(){
    int tmp = 0;
    std::cout << std::endl << "Enter data for  student..." << std::endl;
 
    std::cout << "Full name = ";
    std::cin >> fullname;
 
    std::cout << "Grant = ";
    std::cin >> grant;
 
    std::cout << "Count examenation = ";
    std::cin >> m;
 
    for (int i = 0; i < m; ++i){
        std::cout << "Score for " << i+1 <<" examenation = ";
        std::cin >> tmp;
        assessments.push_back(tmp);
    }
}
 
bool student::isgranted() const{
    return (grant) ? true : false ;
}
 
bool student::islongX(int assessment) const{
    for (int i = 0; i < assessments.size(); ++i)
        if (assessments[i] <= assessment) return true;
    return false;
}
 
 
 
 
int main()
{
    const int cnt_stydent = 3;
    student stud[cnt_stydent];
 
    int cnt_grant_styd = 0;
    int cnt_2stud = 0; //количество получивших 2
    int cnt_45stud = 0; //количество получивших 4 или 5
 
    for (int i = 0; i < cnt_stydent; ++i){
        stud[i].setdata();
        if ( stud[i].isgranted() ) ++cnt_grant_styd;
        if ( stud[i].islongX(4) ) ++cnt_45stud;
        if ( stud[i].islongX(2) ) ++cnt_2stud;
    }
    std::cout << std::endl << std::endl  << "::RESULT::" << std::endl;
    std::cout << "Count granted student = " << cnt_grant_styd << std::endl;
    std::cout << "Count (4,5) student = " << cnt_45stud << std::endl;
    std::cout << "Count (2) student = " << cnt_2stud << std::endl;
 
    return 0;
 
}

return grant;

friend std::istream& operator >>(std::istream&, Student&);

class Foo {
public:
  void SetBar(int bar) {
    mbar = bar;
  }
 
  const int getBar() const {
    return mbar;
  }
 
private:
  int mbar;
};
 
int main() {
  Foo f;
  
  int bar;
  std::cout << "Enter bar:";
  std::cin >> bar;
 
  f.setBar(bar);
 
  std::cout << "Bar: " << f.getBar() << std::endl;
 
  return 0; 
}

std::ifstream&
std::ofstream&

class Base
{
public:
   friend std::ostream& operator <<(std::ostream&, const Base&);
   friend std::istream& operator >>(std::istream&, Base&);
   virtual void input(std::istream&) {}
   virtual void output(std::ostream&) const {}
   //
};
 
class Derived:public Base
{
public:
   virtual void input(std::istream&)=0;
   virtual void output(std::ostream&)const=0;
};
 
class DerivedIO:public Derived
{
public:
   void input(std::istream&) {/**/}
   void output(std::ostream&) const {/**/}
};
 
std::ostream& operator <<(std::ostream& os, const Base& Ob)
{
    Ob.output(os);
    return os;
}
 
std::istream& operator>> (std::istream& is, Base& Ob)
{
     Ob.input(is);
     return is;
}

Derived d;
istream >> d; // Какой-то поток ввода
ostream << d; // Какой-то поток вывода

Derived d;//Derived - абстрактный класс. Следовательно пошлет.

Derived*d=new DerivedIO;
std::cin>>d;
std::cout<<d;

template<class T>
class Base
{
public:
   template<class T2>
   friend std::ostream& operator <<(std::ostream&, const Base<T2>&Ob);
   template<class T2>
   friend std::istream& operator >>(std::istream&, Base<T2>&Ob);
   virtual void input(std::istream&) {}
   virtual void output(std::ostream&) const {}
   //
};
 
template<class T>
class Derived:public Base<T>
{
public:
   virtual void input(std::istream&)=0;
   virtual void output(std::ostream&)const=0;
};
 
template<class T>
class DerivedIO:public Derived<T>
{
public:
   void input(std::istream&) {/**/}
   void output(std::ostream&) const {/**/}
};
 
template<class T>
std::ostream& operator <<(std::ostream& os, const Base<T>& Ob)
{
    Ob.output(os);
    return os;
}
 
template<class T> 
std::istream& operator>> (std::istream& is, Base<T>& Ob)
{
     Ob.input(is);
     return is;
}

...
typedef std::vector<std::vector<int> > matrix_t;
 
class MyClass {
  matrix_t matrix;
...
public:
...
  void setMatrix(const matrix_t & m){
    if ( ! matrix.empty() )
      matrix.clear();
    matrix.resize(m.size());
    for ( int i = 0; i < m.size(); ++i )
      std::copy(m[i].begin(), m[i].end(), std::back_inserter(matrix[i]));
  }
  const matrix_t & getMatrix() const { return matrix; }
...
};