c++类和对象,构造函数,函数重载,复合类。
1.
面向过程和面向对象主要区别可以简单概括为:面向过程的编程是一种直接的编程方法是按照编程语言的思路考虑问题;面向对象的编程是一种抽象度更高的编程方法,它的目标是使
模块的抽象度更高,可复用性更好。
2.
面向对象的三大特征:封装性、继承性和多态性。
3.
封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式。
继承:子类继承父类的属性和方法,实现代码的复用。
多态:C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。
4.
类和对象的关系:类是对象的抽象类型,而对象是类的具体实例。
5.
结构体和类的区别:结构体成员默认是public,类成员默认是private.
6.
//定义一个圆类。属性:圆心坐标以及半径,操作:对圆的信息进行读取、设
//置以及打印,计算两个圆之间的距离。
#include <iostream>
#include <math.h>
using namespace std;
class Cicle
{
float x;
float y;
float r;
public:
void set(float a,float b,float c)
{
x=a;
y=b;
r=c;
}
float getx()
{
return x;
}
float gety()
{
return y;
}
float getr()
{
return r;
}
void print()
{
cout <<"(" << x <<"," << y << ")" << endl;
}
float d(Cicle s)
{
return sqrt((x-s.x)*(x-s.x)+(s.y-y)*(s.y-y));
}
};
int main(int argc, const char * argv[]) {
Cicle a,b;
a.set(1.0, 1.0, 1.0);
b.set(2.0, 2.0, 2.0);
cout << a.getx() <<endl;
cout << a.gety() <<endl;
cout << a.getr() <<endl;
cout << b.getx() <<endl;
cout << b.gety() <<endl;
cout << b.getr() <<endl;
cout <<a.d(b) <<endl;
a.print();
b.print();
return 0;
}
7。
三、构造函数
3.1 构造函数特点
构造函数是一种比较特殊的成员函数,用于创建并初始化对象。声明对象时构造函
数会被编译器自动调用。
构造函数的四个特点:
(1)构造函数的访问权限必须为公有(public); (2)构造函数名和类名相同; (3)构造函数没有返回值; (4)构造函数可以带参数,用于初始化成员变量;
3.2 默认构造函数
默认构造函数分两种: 1、构造函数不带参数;2、构造函数带参数但参数都有默认 值。
Example codes:
Circle(); // Circle(float a=0,float b=0,float c=0);// Circle(float a,float b,float c); //
默认构造函数是指在声明对象时,可以不传递参数,使用空值或默认值对对象进行
初始化,而普通构造函数在声明对象时必须传递参数(实参),否则构造函数的参数(形 参)没有值,编译出错。
如果程序员一个构造函数都没写,编译器将提供一个空的默认构造函数,它不会对
数据成员进行初始化。一旦程序员提供了构造函数,编译器将不提供默认构造函数。对
于每个类都写一个默认构造函数,是程序员的一个好习惯。

#include <iostream>
using namespace std;
class Thing
{
public:
Thing( int a=10, int b=20, int c = 30)//
{ x=a; y=b; z=c; }//,,
void printThing() {
cout<<"x="<<x<<" y="<<y<<" z="<<z<<endl;
} private:
int x;
int y;
int z;
};
int main(int argc, const char * argv[]) {
Thing t;
t.printThing();
Thing s(1);// s.printThing();
Thing r(1,2);
r.printThing();
Thing v(1,2,3);
v.printThing();
return 0;
}
示例分析: 声明t对象时,没有传递参数,那么编译器将会调用默认构造函数,而类中刚好提供
了一个默认构造函数。 假如将Thing( int a=10, int b=20, int c = 30)的三个默认 值都去掉Thing( int a, int b, int c),再次编译程序会发现,声明t对象、s对象、r
No matching constructor for initialization of ‘Thing’ 而v对象不会出错。
8.
函数重载
1.1 函数重载的概念
什么是函数重载?在同一个作用域中,可以有一组具有相同函数名,不同参数列表 的函数,这组函数被称为重载函数。参数列表不同是指参数的个数或参数的类型不同。 如:
void f();
void f(int x);
void f(int x,float y);
如果仅仅是函数的返回值类型不同,不能是函数的重载:
void f(int x);
int f(int x); //error: Functions that differ only in their return
// type cannot be overloaded.
这两个函数不是函数的重载,在同一个作用域内是不能共存的,因为在函数调用时
不知道该调用哪一个函数。
例1-1】构造函数重载
#include <iostream>
using namespace std;
class Thing
{
public:
Thing( ) {x =0; y= 0; z=0;} //default constructor
Thing(int a) { x=a;}
Thing(int a, int b) {x=a;y=b;}
Thing(int a, int b, int c) { x=a; y=b; z=c; }
void printThing() {
cout<<“x=“<<x<<",y="<<y<<",z="<<z<<endl;
}
private:
int x;
int y;
int z; };
int main(int argc, const char * argv[]) {
Thing t;
t.printThing();
Thing s(1);
s.printThing();
Thing r(1,2);
r.printThing();
Thing v(1,2,3);
v.printThing();
return 0;
}
示例分析: (1)类中可以定义多个构造函数,但是必须能够构成函数重载;
(2)声明对象时的参数类型和个数要与构造函数的参数进行匹配。 16年7月22日 星期五
二、初始化列表
在使用C++编程的过程当中,常常需要在构造函数中对类的成员变量进行初始化,通 常的方法有两种:
第一种方法:在构造函数体内通过赋值语句初始化
Thing(int a,int b,int c){ x = a; y = b; z = c; }
第二种方法:使用初始化列表形式初始化
Thing(int a,int b,int c):x(a), y(b), z(c) { }
程序中为什么要使用初始化列表? (1)对于类类型的成员,使用初始化列表效率更高。
(2)有些类型的成员变量必须使用初始化列表的形式初始化,如const成员、引用 成员。
(3)在继承时,子类的构造函数中初始化父类的成员时。
例2-1】初始化列表的使用
// Created by Mr_lee on 16/7/22.
// Copyright © 2016 . All rights reserved.
#include <iostream>
using namespace std;
class Thing
{
public:
Thing(int _x,int _y) : x(_x), y(_y){ }
void print() {
cout<<"x="<<x<<",y="<<y<<endl;
}
private:
int x;
int y; };
int main(int argc, const char * argv[]) {
Thing t(1,1);
t.print();
return 0; }
三、复合类
复合类也称为组合类,是指将一个类的对象作为另一个类的成员变量。 例3-1】复合类示例
#include <iostream>
using namespace std;
class Point
{
public:
Point();
Point(float _x,float _y);
void print();
private:
float x;
float y; };
Point::Point(){ }
Point::Point(float _x,float _y) {
x = _x;
y = _y; }
void Point::print() {
cout<<"("<<x<<","<<y<<")"<<endl;
}
//—————————————— ———————————————// class Circle
{ public:
Circle();
Circle(float x,float y,float r);
void setCircle(float r,Point p);
void print();
private:
float radius;
Point center;
};

Circle::Circle(){} //center
//Point Circle::Circle(float x,float y,float r):center(x,y),radius(r) { }
void Circle::setCircle(float r,Point p) {
radius = r;
center = p; }
void Circle::print() {
cout<<"radius:"<<radius<<endl;
center.print();
}
int main(int argc, const char * argv[]) {
Point p(5,7);
p.print();
Circle c;
c.setCircle(1, p);
c.print();
return 0;
}