C++ 学习总结复习篇

友元的使用
分为友元类和友元函数
    //友元类与友元函数的共同点：都可以让某一个类作为另一个类或者函数的参数。

    //友元类：它让当前类成为另一个类的友元，然后，另一个类可以访问当前类的私有成员。
    #include "stdafx.h"
    #include <iostream>
    using namespace std;

    class myclass
    {
     int m;
     int n;
    public: //若不加public，则编译错误。友元类无法访问私有成员。
     myclass(int i, int j)
     {
     m = i;
     n = j;
     }
     friend class test; //友元类的使用
     //简单点讲就是外部函数的内嵌可以访问
     friend int sub(myclass k); //友元函数的使用
    };

    class test
    {
    public:
     void Test(myclass k)
     {
     cout << k.m << " " << k.n << endl;
     }
    };

    int sub(myclass k)
    {
     return k.m;
    }

    int _tmain(int argc, _TCHAR* argv[])
    {
     myclass *p = new myclass(3,6);
test *t = new test();
     t->Test(*p);
     cout << sub(*p) <<endl;
     return 0;
    }
突然想到static 、 const 、 static const 以及它们的初始化
Const 定义的常量超出其作用域会被释放掉，而static 定义的静态常量在函数直线后不会释放其存储空间。
对于各自的初始化规则如下：
1. const定义的常量，需要在初始化列表中初始化。
2. static定义的静态变量，需要在类的外部初始化。
3. const static 与 static const 一样，它也是需要在类的外部初始化。
4. const 形式的方法其主要作用是为了防止成员函数修改成员变量的值。作用域为某个对象，不同的对象可以有不同的const定义的常量的值。
5. static形式的方法其主要作用是为了作为全局方法使用。作用域为整个类。一般作为工具类使用，不同的对象可以修改static静态变量的值，
  而无法修改const static 静态常量的值。
注意：要想在类中建立恒定不变的值，除了用const static外，还可以用enum 枚举实现。

举例如下：
// BlankTest.cpp : 定义控制台应用程序的入口点。
//
// const 、 static 、 const static 、 enum 之间的区别与联系
#include "stdafx.h"
#include <iostream>
using namespace std;

class myclass
{
    const int m;
public:    static int n;
    const static int mn;
    enum
    {
        size1 = 50, //枚举变量中没有；冒号，只有，逗号。
        size2 = 60
    };
public: //若不加public，则编译错误。友元类无法访问私有成员。
    static void print();
    const void print2();

myclass(int a);
};

int myclass::n = 10; //静态成员的定义+初始化
const int myclass::mn = 20;

myclass::myclass(int a):m(a) //用a 来初始化const成员，此处可以直接写一个数字，比如10，都是没有问题的。
{
    n += 1;//说明我们在构造函数里面可以对static变量进行更改
}

void myclass::print()
{
    cout << "count= " << mn << endl;
}

const void myclass::print2()
{
    //m = 20; //错误，错误提示：表达式必须是可修改的左值。
    cout << "const = " << m << endl;
    cout << "static = " << n << endl;
}
int _tmain(int argc, _TCHAR* argv[])
{
    myclass a(10);
    a.print();//通过对象访问静态成员函数
    myclass::print();//通过类访问静态成员函数

    a.print2();
    a.n += 1; //static 变量是可以更改的。而static const 变量是不可更改的。
    a.print2();

    cout <<"enum = "<< a.size1 << endl;
    //a.mn += 1;//error，静态常量无法修改左值。
    return 0;
}
继承与派生
继承与派生其实是一个意思的两种表达方式而已。
C++允许多继承，记住构造函数与析构函数的用法。
派生类与基类构造函数与析构函数的执行顺序：一般先执行基类的构造函数，然后执行派生类中对象成员的构造函数，最后执行派生类自身的构造函数。
析构顺序与构造函数的执行顺序相反。
记得类的访问属性的变化 class a : public/protected/private b, xxx c{ };
这个当中，属性的变化会影响派生类当中的成员变量自身的属性变化。有着同类合并的原则。
下面是举例：
// BlankTest.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;

class myclass
{
public:
int m;
int n;
myclass(int i, int j):m(i),n(j){}

void set_m(int m2)
{
     m = m2;
}

const int get_m()
{
     return m;
}

void set_n(int m1)
{
     n = m1;
}
const int get_n()
{
     return n;
}
};

class myclass2: public myclass
{
protected:
    int k;
public:
    myclass2(int i ,int j, int p):myclass(i,j){k = p;}

    void set_k(int m3)
    {
        k = m3;
    }
    const int get_k()
    {
        return k;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    myclass2 l(3,4,5);
    cout << l.get_m() << " " << l.get_n() << " " << l.get_k() << endl;
    return 0;
}
函数
函数就和变量一样，先定义后使用。
而且和传统意义上的函数有异曲同工之妙。
举例：
// BlankTest.cpp : 定义控制台应用程序的入口点。
//函数的参数的两种传递方式：指针传递，值传递，现在又有引用传递。
//对于指针与引用的区别：
//当对象为空，必须用指针，当对象在使用过程中会改变时，只能用指针。因为：没有空引用，且引用是一个常量，不能对其重新赋值。
#include "stdafx.h"
#include <iostream>
using namespace std;

class myclass
{
public:
int *p;
myclass(int num)
{
     p = new int[num];
     for (int i = 0; i < num; ++i)
     {
         cin >> p[i];
     }
}
void acc(int num) //选择排序
{
     for (int i = 0; i < num; ++i)
     {
         for (int j = i + 1; j < num; ++j)
         {
             if (p[i] < p[j])
             {
                 int temp = p[i];
                 p[i] = p[j];
                 p[j] = temp;
             }
         }
     }
}
void display(int num)
{
     for (int i = 0; i < num; ++i)
     {
         cout << p[i] << " " << endl;
     }
}

~myclass()
{
     delete[] p;
}
};

int _tmain(int argc, _TCHAR* argv[])
{
    myclass cc(10);
    cc.acc(10);
    cc.display(10);
    return 0;
}

函数重载：返回值与名字相同，而函数特征不同的两个或多个函数，带有const属性的不算是重载。
举例：
// BlankTest.cpp : 定义控制台应用程序的入口点。
//函数的重载不是重复
#include "stdafx.h"
#include <iostream>
using namespace std;

static const double PI = 3.1415926;
double ZC(double radius)
{
    return 2*PI*radius;
}

double ZC(double width, double height)
{
    return 2*(width+height);
}

int _tmain(int argc, _TCHAR* argv[])
{
    double r = 3;
    double w = 1;
    double h = 2;

    cout << "r zc = " << ZC(r) << endl;
    cout << "rect zc = " << ZC(w,h) << endl;
    return 0;
}

递归的使用：
一定要有终止条件，要有递推关系式。
举例：
// BlankTest.cpp : 定义控制台应用程序的入口点。
//函数的重载不是重复

#include "stdafx.h"
#include <iostream>
using namespace std;

int find(int n, int m);
int _tmain(int argc, _TCHAR* argv[])
{
    int m = find(0,1);
    cout << m << endl;
    return 0;
}
//普通实现
//int find(int n, int m)
//{
//    while(1)
//    {
//        if (n > 200)
//        {
//            return m-1;
//        }
//        else
//        {
//            n += m*m;
//            m++;
//        }
//    }
//}
//递归实现
int find(int n, int m)//有一个返回值即可
{
    n = n + m*m; //递推关系式 fn = fn-1 + m*m;
    if (n < 200)
    {
        m++;
        find(n,m);//相当于循环
    }
    else
    {
return m;
    }
}

//递归实现
int find(double a, int b)//有一个返回值是 fn-1
{
    if (b == 0)
    {
        return 1;
    }
    else
    {
return a*find(a,b-1); // 递推式 fn = fn-1 * a;
    }
}
结构体
涉及到的概念有结构体、联合体、位域等。
举例：
// BlankTest.cpp : 定义控制台应用程序的入口点。
//map 的用法http://blog.csdn.net/sunshinewave/article/details/8067862

#include "stdafx.h"
#include <iostream>
using namespace std;
typedef struct test
{
int a:3;
int b:4;
int c:5;
}test;
typedef struct Date
{
     int month;
     int day;
     int hour;
} Date;

Date oneday()
{
     Date ad;
     cin >> ad.day >> ad.hour >> ad.month;
     return ad;
}

void show(Date &oneday) //此处改为指针也可以。
{
     cout << oneday.day << " " << oneday.hour << " " << oneday.month << endl;
}
int _tmain(int argc, _TCHAR* argv[])
{
    Date one = oneday();
    show(one);
    return 0;
}

C++ 学习总结 复习篇

C++ 学习总结复习篇