《C++数据结构-快速拾遗》 基础常识

1.命名空间函数

 namespace wjy
 {
     void print()
     {
         cout<<"";
     }
     int load(int num)
     {
         return num;
     }
 }
 using namespace wjy;

2.函数数组的实现

　　2.1利用重载函数实现　　

　　　　名字相同，参数或者返回值不同等。

 int max(int a, int b)
 {
     return a>b?a:b;
 }
 double max(double a, double b)
 {
     return a>b?a:b
 }
 float max(float a, float b)
 {
     return a>b?a:b
 }

　　2.2利用函数指针实现

　　　　注释：指针函数和函数指针的相关知识-->>http://blog.csdn.net/ameyume/article/details/8220832

 #define _CRT_SECURE_NO_WARNINGS
 #include <iostream>
 using namespace std;

 typedef struct DATA
 {
     int sNumb;
     char sName[];
     float sMath;
 }DATA;//结构体定义比较类型
 typedef bool(*FUNCP)(DATA, DATA);//定义指针函数类型
 bool byNumb(DATA p, DATA m)
 {
     return (p.sNumb > m.sNumb);
 }
 bool byName(DATA p, DATA m)
 {
     return strcmp(p.sName, m.sName) < ;
 }
 bool byMath(DATA p, DATA m)
 {
     return (p.sMath > m.sMath);
 }
 int main(int argc, char*argv[])
 {
     DATA data1, data2;
     data1.sNumb = ;
     strcpy(data1.sName, "abc");
     data1.sMath = 1.5;

     data2.sNumb = ;
     strcpy(data2.sName, "wjy");
     data2.sMath = 2.9;

     FUNCP ps[] = { byNumb,byName,byMath };
     cout << ps[](data1, data2) << ps[](data1, data2) << endl << ps[](data1, data2) << endl;
     return ;
 }

3.内联函数

C++实现：

inline max(itn a,int b)
{
	return a>b?a:b;
}

C语言实现：

define max(a,b) a>b?a:b;

4.堆空间申请内存

typedef struct SData:
{
	int nNum;
	char sNum[20];
};

 /*在堆空间申请内存*/
     int *p = new int;//申请一个普通变量 delete p
     int *p = new int[];//申请数组     delete []p
     SData *p = new SData;//申请结构体对象 delete p
     SData *p = new SData[];//申请结构体数组 delete []p

5.成员函数

成员函数不占空间！！！

 #include <iostream>
 using namespace std;
 struct STime
 {
     int nHour;
     int nMin;
     int nSec;
     void SetTime(int a,int b,int c)
     {
         nHour = a;
         nMin = b;
         nSec = c;
     }
 };
 int main(int argc,char**argv[])
 {
     STime wjy;
     wjy.SetTime(,,);
     cout << sizeof(wjy);
     while();
     return ;
 }

C++成员函数用C语言实现：

 #include <iostream>
 using namespace std;
 typedef struct STime
 {
     int nHour;
     int nMin;
     int nSec;
 };
 void SetTime(STime* p,int a, int b, int c)
 {
     p->nHour = a;
     p->nMin = b;
     p->nSec = c;
 }
 int main(int argc, char**argv[])
 {
     STime wjy;
     SetTime(&wjy,, , );
     cout << sizeof(wjy)<<endl<<wjy.nHour<<endl << wjy.nMin<< endl << wjy.nSec;
     //cout<<"123";
     while ();
     return ;
 }

6.预编译语句

 #if true
     //执行语句
 #endif

 #if false
     //不执行语句
 #endif

#ifdef _test_
    //如果_test_被#define，那么就执行这句话
#else
    //如果没被#define，就执行这句话

#define _test_
#ifdef _test_
    //run
#else
    //not run

7.const的作用

　　这里暂时不考虑，等找工作前期再补上！https://chuanke.baidu.com/v1760453-135963-522762.html

8.类

　　参考吕鑫老师教程，进行类的基础概念巩固。

　　参考类两种初始化的区别：http://blog.csdn.net/ianchoi/article/details/6917899

　　8.1类的基础概念

　　　　A.类的赋值使用拷贝构造函数，看拷贝的类型决定深拷贝和浅拷贝！　　

CList::CList(CList& p)
{
    memcpy(this,&p,sizeof(p));//拷贝构造函数
}
int a(10);//这也是拷贝构造函数的一种

　　　　B.先申请的后释放空间，后申请的先释放空间

 //先释放list2，后释放list1
 CList list1,list2;

　　　　C.static函数在类之中等于全局函数

class CList
{
    DATA data;
    static int copy(DATA a,DATA b)//等于全局函数，this调用不到
    {
        a = b;
    }
}

 CList::a = ;//static初始化在类外全局初始化
 class CList
 {
     static DATA a;
 public:
     DATA data;
     static int copy(DATA a,DATA b)//等于全局函数，this调用不到
     {
         a = b;
     }
 };　　　　

　　　　D.在类中定义函数都会增加一个参数this

 class wjy
 {
     void max(int a, int b )
     {
         return a>b?a:b;
     }
 }
 typedef bool(*FUNCP)(DATA,DATA);//定义指针函数类型就不能调用max，因为max有三个参数

　　　　F.函数中的static类

 #include <iostream>
 usiang namespace std;

 typedef DATA int;
 class wjy
 {
     DAAT node = ;
 }
 void test()
 {
     static wjy class1;
     wjy class2;
 }
 int main(int argc,char*argv[])
 {
     test();//static第一次进入的时候进行构造.class2在每一次进入test的时候都进行构造
     test();//class2在每一次进入test的时候都进行构造,同时退出的时候也进行析构
     test();//class2在每一次进入test的时候都进行构造
     return ;//static 在main函数退出的时候才进行析构
 }

　　8.2类的两种初始化区别

　　　　注释：曾经去面试的时候被问到了，一问三不知，属实尴尬！

 //---在定义的时候分配空间，在构造的时候存放值
 //---浪费内存，有时候定义的时候占一个空间，赋值的时候又占一个空间
 class CList
 {
     int data;
     CList():
     {
         data =;
     }
 }

 //---在定义的时候分配空间并且初始化
 //---初始化的顺序是按照定义的顺序执行，先初始化data，后初始化p
 //---只占用一次内存
 //---特殊的类型必须使用，例如：int为一个类，这个类只有一个参数的构造。
 //---                           int为一个const和引用的时候，不能再private初始化。
 class CList
 {
     int data;
     int p;
     CList():p(),data()
     {
     }
 }
 //----当然这两种初始化的顺序肯定是后者（列表函数初始化）先赋值而且好了。

https://chuanke.baidu.com/v1760453-135963-528979.html