C++ 类及其他

Newdelete

  New 和 delete运算符是动态分配、销毁内存的，它主要是可以对指针类型的变量进行内存的分配。例子如下：

#include<iostream>

usingnamespace std;

int main()

{

    int *p = new int[10];

    char *q = new char[10];

    for (int i = 0; i < 10; i++)

        p[i] =i;

    q[0] = 'a';

    q[1] = 'b';

    q[2] = 'c';

    q[3] = 'd';

    for (int j = 0; j < 10; j++)

        cout << p[j] <<"";

        cout << endl;

    for(int o = 0 ; o < 10 ;o++)

        cout << q[o] <<"";

        cout << endl;

    delete p;

    delete[]q;

        return 0;

}

内联函数和重载函数

Inline(内联函数)

  内联函数：我们知道的，函数调用时有是假开销的。如果函数本身只有几条语句，执行的速度会非常快，而且函数反复被执行很多次，相比之下，调用函数所产生的这个开销就会显得比较大。为了减少函数调用的开销，就可以使用内联函数机制。编译器处理处理内联函数时，是将整个函数的代码插曲到调用语句处，而不会产生调用函数的语句。也就是说没有参数入栈、返回地址入栈等操作了。例如，在执行下面的语句时：

inline Max(inta, intb)

{

    if (a > b)

        cout <<" The Biger number is "<<a<< endl;

    else

        cout <<" The Bigere number is "<<b<< endl;

}

当有语句     int k = Max(a1, a2);   时，编译器其实执行的是一下操作：

    if (a1 > a2)

        temp =a1;

    else

        temp =a2;

    k = temp;

 

函数重载

        一个或者多个函数，名字相同，然而参数个数或者类型不同，就叫作函数重载。函数重载使得函数重载命名变得简单，编译器会根据调用语句中的实参的个数和类型判断应该调用哪一个。

 

函数的缺省参数

        函数参数可缺性的目的是提高程序的可扩充性。也就是说，某个写好的函数要添加新的参数，而原先那些调用该函数的语句，未必需要使用新增的参数，那么为了比避免对原先那些函数调用语句的修改，就可以使用缺省参数。

面向对象程序设计

结构化程序设计：复杂的大问题-----层层分解/模块化-------若干子问题

                                          自顶向下，逐步求精

   程序 = 数据结构（变量）+ 算法（函数形式实现，操作数据结构）

                 当规模变大时，程序会理解难、修改难、差错难、重用难

面向对象程序设计：面向对象的程序是各个类的相加，程序设计也就是设计类。

例如程序：

#include<iostream>

usingnamespace std;

classCRectangle {

public:

    int w, h;

    void  Init(int_w, int_h)

    {

        w = _w;

        h = _h;

    }

    int Area()

    {

        return w * h;

    }

    int Perimeter()

    {

        return 2 * (w + h);

    }

};

int main()

{

    int w, h;

    CRectangle r;

    cin >> w >> h;

    r.Init(w,h);

    cout << r.Area() << endl << r.Perimeter();

    return 0;

}

 

注意：每个对象都有各自的存储空间，其中一个对象的成员变量改变时，不会影响到其他的对象。

     各个对象之间可以进行 = 号的赋值，但是对于<  <=  >  >= !=  ==  这些比较的运算符是“重载”的。

     类中的成员函数可以不写在类的定义中，在定义类时，只需要先将成员函数进行声明即可。类名：：成员函数名（….）{……}

 

 

  类的成员以及成员函数的访问方法：

1、  普通的成员变量和函数的访问：类名.变量或者是函数名

2、  指针类型的类的用法：类名->变量或者是函数名

3、  引用类型的类的用法：引用的类名.变量或者是函数名

 

类成员的可访问范围

  private 指定私有成员，智能在成员函数内被访问

  public 指定共有成员，可以在任何地方被访问

  protected 指定保护成员

注意：缺省为私有成员，只可以被同一个类中的成员函数调用。

强制对成员变量的访问一定要通过成员函数进行，这可以保护成员变量。

 

      

 

类型转换构造函数 constructor

构造函数：是成员函数的一种、名字与类名相同、可以有参数、不能有返回值、可以有多个构造函数、可以用来初始化对象

 

 

直接看下面的例子：

#include<iostream>

usingnamespace std;

classComplex {

public:

    double real, imag;

    Complex(inti) //类型转换构造函数

    {

        cout <<"IntConstructor Called."<< endl;

        real =i, imag = 0;

    }

    Complex(doubler, doublei)

    {

        real =r;

        imag =i;

    }

};

int main()

{

    Complex c1(7, 8);

    Complex c2 = 12;

    c1 = 9;   //9被临时转换为一个Complex构造函数

    cout << c1.real <<","<< c1.imag<< endl;

    return 0;

}

 

结果：

 

Intconstructor Called.

Intconstructor Called.

9,0

 

析构函数 deconstructor

 

析构函数：是成员函数的一种、名字与类名相同、在前面加~、没有参数和返回值、一个类最多只有一个析构函数。主要是在对象消亡前做善后工作的，当对象消亡时，构造函数将会被调用。当类没有写析构函数时，编译器会自动生成析构函数。

 

看例子：

#include<iostream>

usingnamespace std;

classTest {

public:

    int a;

    ~Test()

    {

        cout <<" Deconstructor Called. "<< endl;

    }

};

int main()

{

    Test array[7];

    cout <<" Printf End . "<< endl;

    return 0;

}

 

结果：

Printf End

Deconstructor Called.

Deconstructor Called.

Deconstructor Called.

Deconstructor Called.

Deconstructor Called.

Deconstructor Called.

Deconstructor Called.

 

 

析构函数与运算符delete  :

Test *pTest;

Ptest = new Test;   //构造函数调用

Delete pTest;   //析构函数调用

 

Ptest = new Test[3];    //构造函数调用三次

Delete [] pTest;     //析构函数调用三次

 

 

 

 

一个综合的例子:

#include<iostream>

usingnamespace std;

classTest {

    int id;

public:

    Test(inti)

    {

        id = i;

        cout <<" id =  "<< id  <<" Constructed ."<< endl;

    }

    ~Test()

    {

        cout <<"id = "<< id  <<" Deconstructed . "<< endl;

    }

};

Test d1(1);

void Fun()

{

    staticTest d2(2);

    Test d3(3);

    cout <<" Fun() "<< endl;

}

int main()

{

    Test d4(4);

    d4 = 9;

    cout <<"main"<< endl;

    { Test d5(5); }

    Fun();

    cout <<" main ends . "<< endl;

}

 

结果：

注意几点：

{}是一个作用域

Static类型的变量一直会存在到程序的结束

复制构函数会在赋值时先直接构造，然后即可析构

在C++中，先构造的后析构，析构和构造的顺序是相反的。

 

 

 

 

 

 

 

 

静态成员变量和静态成员函数 static

Sizeof不会计算static变量，它是共享的。

普通成员变量每个对象都各自有一份，而静态成员变量就一共一份，为所有对象所共享。

普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用于某个对象。

静态成员不需要通过对象就可以访问。

访问方法：

1)      类名::成员名

2)      对象名.成员名

3)      指针 -> 成员名

4)      应用.成员名

静态成员变量本质上是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在。

静态成员函数本质上是全局函数。

为什么?要静态成员：设置静态成员机制的目的是将和某些类紧密香瓜under全局变量和函数写到类里面，看上去像一个整体，易于维护和理解。

注意：必须在定义类的文件中对静态成员变量进行一次说明或者初始化。

在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

 

 

成员对象和封闭类

成员对象:一个类的成员变量是另一个类的对象。？？就是一个类中的成员变量是其他相关类（数据类型是“类”）。

封闭类：包含成员对象的类。

 

封闭类构造函数的初始化列表：

类名：：构造函数（参数表）：成员变量（参数表） {}

 

会先调用成员对象的类，然后会是封闭类，的构造函数

  析构上，先析构封闭类，然后是析构成员对象。

 

 

友元 friend

一个类的友元函数可以访问该类的私有成员。

可以将一个类的成员函数（包括析构函数、构造函数）用到另一个类中。

友元类之间不能传递、不能继承。

 

 

this 指针

历史：C++程序到C程序的翻译

 

题目答案：

#include<iostream>

using namespace std;

class A {

public:

   int val;

   A(int n = 0) { val = n; };

    A&GetObj() {  return *this ; };

   // 在此处补充你的代码

};

 main() {

    Aa;

   cout << a.val << endl;

   a.GetObj() = 5;

   cout << a.val << endl;

}

 

#include <iostream>

using namespace std;

class Sample{

public:

   int v;

   Sample(int n):v(n) {  };

   Sample (Sample &x) { v = 2*x.v; };

 

// 在此处补充你的代码

};

int main() {

   Sample a(5);

   Sample b = a;

   cout << b.v;

   return 0;

}

 

#include <iostream>

using namespace std;

class Base {

public:

   int k;

   Base(int n):k(n) { }

};

class Big {

public:

   int v; Base b;

   Big (int n):v(n),b(n) {};

   Big (Big &x):b(x.b.k),v(x.v) {};

// 在此处补充你的代码

};

int main() {

   Big a1(5);    Big a2 = a1;

   cout << a1.v << "," << a1.b.k << endl;

   cout << a2.v << "," << a2.b.k << endl;

   return 0;

}