• Home
• Syllabus
• Schedule
• Checkin
• Homework
  • HW0
  • HW1
  • HW2
  • HW3
  • HW4
  • HW5
  • HW6
  • HW7
  • HW8
• Examples
• Piazza
• Slides
• Other Info

See this page as a slide show

CS253 Struct And Class

struct

• struct is the old C way of doing things.
• In C, there were no methods—only data members.
• Structs are still useful for holding unadorned data.

struct Point {
    int x, y;
};
Point p;             // Note lack of new
cout << p.x << '\n'; // uninitialized value
p.x = 8;
p.y = 9;
cout << p.x << ',' << p.y << '\n';

c.cc:5: warning: 'p.main()::Point::x' is used uninitialized in this function
0
8,9

class

• Classes have methods and data. Data is usually private.
• A class should have public methods to be useful, (e.g., a ctor) but private methods are also common.
• public & private define sections of the class.

class Point {
  public:
    Point(int a, int b) { x = a; y = b; }   // constructor (alias ctor)
    int get_x() const { return x; }         // accessor
    int get_y() const { return y; }         // accessor
    void go_right() { x++; }                // mutator
  private:
    int x, y;                               // Hands off!
};

Output

To make a class work for output, define operator<< appropriately:

class Point {
  public:
    Point(int a, int b) { x = a; y = b; }   // ConstrucTOR
    int get_x() const { return x; }         // accessor
    int get_y() const { return y; }         // accessor
    void go_right() { x++; }                // mutator
  private:
    int x, y;                               // Hands off!
};

ostream &operator<<(ostream &out, const Point &p) {
    return out << p.get_x() << ',' << p.get_y();
}

int main() {
    Point p(12, 34);
    cout << p << '\n';      // invoke operator<<
}

12,34

Example

class Quoted {
    string s;
  public:
    Quoted(const string &word) : s(word) { }
    string get() const { return "“" + s + "”"; }
};

ostream &operator<<(ostream &os, const Quoted &rhs) {
    return os << rhs.get();
}

int main() {
    Quoted name("Robert Bruce Banner");
    cout << "I am " << name << ".\n";
}

I am “Robert Bruce Banner”.

methods: in-line and not

Methods can be defined inside or outside of the class.

class Quoted {
    string s;
  public:
    Quoted(const string &word) : s(word) { }
    string get() const; // declaration only
};
string Quoted::get() const {
    return "“" + s + "”";
}
ostream &operator<<(ostream &os, const Quoted &rhs) {
    return os << rhs.get();
}

int main() {
    Quoted name("Slartibartfast");
    cout << "I am " << name << ".\n";
}

I am “Slartibartfast”.

Protection

• Class members (data & methods) can be public, private, or protected.
• The default is private for a class, public for a struct.
• public: anyone can access them
• private: nobody except other methods of this class can access them
• protected: can be accessed by this class, and by immediately derived class

Protection

class Foo {     // A class, with a variable of each type
  public:
    int pub;    // I’m public!
  private:
    int priv;   // I’m private!
  protected:
    int prot;   // I’m a little teapot, short & stout.
};

int main() {
    Foo f;

    f.pub = 1;          // great
    // f.priv = 2;      // nope
    // f.prot = 2;      // nope

    return f.pub;
}

Friends

Friend Declarations

One class can declare another class/method/function to be its friend:

class Foo {
    friend class Bar;
    friend double Zip::zulu(int) const;
    friend int alpha();
    friend std::ostream &operator<<(std::ostream &os, const Foo &);
  private:
    int x,y;
};

• All the methods of class Bar can access our data.
• So can the method zulu(int) const of the class Zip.
• So can the function (not method) alpha().
• So can the function operator<<(ostream &, const Foo &).

Restrictions

• Friendship is offered, not demanded
  • class A, via friend class B, offers friendship to class B.
• Friendship is not symmetric
  • If C is D’s friend, then D is not necessarily C’s friend.
• Friendship is not transitive
  • If E & F are friends, and F & G are friends, then E & G are strangers.
• Friendship is not inherited
  • If H is I’s friend, and I is the parent of J, then H & J are strangers.
• Inheritance does not imply friendship
  • If K is L’s parent, then K & L are strangers.

Don’t go nuts

• C++ programmers often fall in love with friend declarations, and overuse them.
• friend should be your last tool, not your first one.
  • Like casting.
• Minimize access: prefer method friendship to class friendship.
• Create accessors (getters) and mutators (setters) instead.
• If you’re using friend declarations to avoid the overhead of method calls, then you have no faith in current compilers. They’re quite good at inlining methods.

User: Guest