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

1.命名空间函数

namespace wjy
{
    void print()
    {
        cout<<"123";
    }
    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[10];
    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) < 0;
}
bool byMath(DATA p, DATA m)
{
    return (p.sMath > m.sMath);
}
int main(int argc, char*argv[])
{
    DATA data1, data2;
    data1.sNumb = 10;
    strcpy(data1.sName, "abc");
    data1.sMath = 1.5;

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

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

 

 

 

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[10];//申请数组     delete []p
    SData *p = new SData;//申请结构体对象 delete p
    SData *p = new SData[10];//申请结构体数组 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(1,2,3);
    cout << sizeof(wjy);
    while(1);
    return 0;
}

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,1, 2, 3);
    cout << sizeof(wjy)<<endl<<wjy.nHour<<endl << wjy.nMin<< endl << wjy.nSec;
    //cout<<"123";
    while (1);
    return 0;
}

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 = 0;//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 = 100;
}
void test()
{
    static wjy class1;
    wjy class2;
}
int main(int argc,char*argv[])
{
    test();//static第一次进入的时候进行构造.class2在每一次进入test的时候都进行构造
    test();//class2在每一次进入test的时候都进行构造,同时退出的时候也进行析构
    test();//class2在每一次进入test的时候都进行构造
    return 0;//static 在main函数退出的时候才进行析构
}

 

　　8.2类的两种初始化区别

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

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

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

 

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