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;
}