CS 225
Lab_intro
Worksheet on Website
Intro
Logistics
10 points each lab.
120 total.
Attendance starts week 3 for a possibility of up to 40 points extra credit.
Survival Guide:
Learn C++ on time
Lab sessions:
Topics covered in the lecture
Variables in C++:
Topics covered in the lecture
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once is a non-standard but widely supported preprocessor directive designed to cause the current file to be included only once in a single compilation.
Wikipedia
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
7
8
9
10
11
int main() {
Cube c;
cout << c.getVolume()<< c.length_;
return 0;
}
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
...
double Cube::getVolume(){
...}
:: - scope resolution operator
Constuctor
A constructor is a special member function that initializes the object.
#pragma once
class Cube {
public:
double getVolume();
double getSurfaceArea();�� private:� double length_;�� };
Cube.h
1
2
3
4
5
6
7
8
9
10
11
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main() {
Cube c;
cout << c.getVolume();
return 0;
}
Cube.cpp
#pragma once
class Cube {
public:
Cube();
double getVolume();
double getSurfaceArea();�� private:� double length_;�� };
Cube.h
1
2
3
4
5
6
7
8
9
10
11
#include "Cube.h"
namespace cs225 {
Cube::Cube(){
length_=1;
}
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main() {
Cube c;
Cube c2(5);
cout << c.getArea();
return 0;
}
Cube.cpp
#pragma once
class Cube {
public:
Cube();
Cube(double w);
double getVolume();
double getSurfaceArea();�� private:� double length_;�� };
Cube.h
1
2
3
4
5
6
7
8
9
10
11
#include "Cube.h"
namespace cs225 {�
Cube::Cube(){
length_=1;
}
Cube::Cube(double w){
length_=w;
}�
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Cube.cpp
#pragma once
class Cube {
public:
Cube();
Cube(double w);
double getVolume();
double getSurfaceArea();�� private:� double length_;�� };
Cube.h
1
2
3
4
5
6
7
8
9
10
11
#include "Cube.h"
namespace cs225 {�
Cube::Cube(){
length_=1;
}
Cube::Cube(double w){
length_=w;
}�
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main() {
Cube c;
Cube c2(5);
cout << c.getVolume()<< c2.getVolume();
return 0;
}
#pragma once
class Cube {
public:
Cube();
Cube(double w);
double getVolume();
double getSurfaceArea();�� private:� double length_;�� };
Cube.h
1
2
3
4
5
6
7
8
9
10
11
#include "Cube.h"
namespace cs225 {�
Cube::Cube(){
length_=1;
}
Cube::Cube(double w){
length_=w;
}�
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main() {
Cube c;
Cube c2(5);
cout << c.getVolume()<< c2.getVolume();
return 0;
}
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
A namespace is a declarative region that provides a scope to the identifiers (names of the types, function, variables etc) inside it.
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
...
namespace cs225 {
double Cube::getVolume(){
}
...
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace cs225 {
double Cube::getVolume(){
}
using cs225::Cube;
double getVolume(){
}
#pragma once
namespace cs225 {
class Cube {
public:
double getVolume();
double getSurfaceArea();����� private:� double length_;�� };
}
Cube.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Cube.h"
namespace cs225 {
double Cube::getVolume() {
return length_ * length_ *� length_;
}
double� Cube::getSurfaceArea() {
return 6 * length_ *
length_;
}
}
Cube.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
double cs225::Cube::getVolume(){
}
namespace cs225 {
double Cube::getVolume(){
}
using cs225::Cube;
double getVolume(){
}
Write your first class: HSLAPixel
Specification
The class HSLAPixel contains four public member variables:
Additionally, you will need to complete three constructors defined in the doxygen;
CS 225’s PNG Class
Inside of your cs225 directory, you have: PNG.h and PNG.cpp.
We have provided an already complete PNG class that saves and loads PNG files and exposes a simple API for you to modify PNG files.
In C++, the scope resolution operator, ::, denotes a function or variable is a member of a class. The API for the PNG class includes:
Open the doxygen for PNG;
Example Usage
Suppose we want to transform an image to grayscale. A pixel with a saturation set to 0% will be a gray pixel. Here’s this transformation applied to the Alma Mater:
The code fragment:
1
2
3
4
5
6
7
8
9
10
11
12
13
PNG grayscale(PNG image) {
for (unsigned x = 0; x < image.width(); x++) {
for (unsigned y = 0; y < image.height(); y++) {� // Get a reference to the pixel at (x, y):
HSLAPixel & pixel = image.getPixel(x, y);
// Set the pixel's saturation to 0:
pixel.s = 0;
}
}
return image;
}
Reference Variable
A reference variable is an alias to an existing variable.
Key Idea: They are the same variable!
Modifying the reference variable also modifies the original variable being aliased.
Reference Variable
A reference variable is an alias to an existing variable.
1
2
3
4
5
6
7
8
9
10
11
12
13
PNG grayscale(PNG image) {
for (unsigned x = 0; x < image.width(); x++) {
for (unsigned y = 0; y < image.height(); y++) {�
HSLAPixel & pixel = image.getPixel(x, y);
pixel.s = 0;
}
}
return image;
}
Reference Variable
A reference variable is an alias to an existing variable.
1
2
3
4
5
6
7
8
9
10
11
12
13
PNG grayscale(PNG image) {
for (unsigned x = 0; x < image.width(); x++) {
for (unsigned y = 0; y < image.height(); y++) {�
HSLAPixel & pixel = image.getPixel(x, y);
pixel.s = 0;
}
}
return image;
}
lab_intro:
complete the functions: