关于学习C++过程中需要的知识点拓展

1.At          (int nIndex, ELT def = 0)函数的用法

可以使用[]或者at()方法来访问字符串中的字符,起始索引是0.最大有效索引是string.length()-1.(特别的,如果是const string类型的对象,那么最大有效索引是string.length(),最后一个字符是'\0’.)

[]和at()的区别在于[]不检查索引是否有效,而at()在遇到无效索引时会抛出out_of_range异常.

2.inline 内联函数的标志的作用及用法

1． inline 定义的类的内联函数，函数的代码被放入符号表中，在使用时直接进行替换，（像宏一样展开），没有了调用的开销，效率也很高。

2． 很明显，类的内联函数也是一个真正的函数，编译器在调用一个内联函数时，会首先检查它的参数的类型，保证调用正确。然后进行一系列的相关检查，就像对待任何一个真正的函数一样。这样就消除了它的隐患和局限性。

3． inline 可以作为某个类的成员函数，当然就可以在其中使用所在类的保护成员及私有成员

注意事项：首先，你可以使用inline函数完全取代表达式形式的宏定义。另外要注意，内联函数一般只会用在函数内容非常简单的时候，这是因为，内联函数的代码会在任何调用它的地方展开，如果函数太复杂，代码膨胀带来的恶果很可能会大于效率的提高带来的益处。内联函数最重要的使用地方是用于类的存取函数。

另外要注意，内联函数一般只会用在函数内容非常简单的时候，这是因为，内联函数的代码会在任何调用它的地方展开，如果函数太复杂，代码膨胀带来的恶果很可能会大于效率的提高带来的益处。内联函数最重要的使用地方是用于类的存取函数。

4.realloc用法

原型：extern void *realloc(void *ptr, size_t newsize);

用法：#include <stdlib.h>

功能：改变ptr所指内存区域的大小为newsize长度。

说明：如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。

5.qsort的用法

    void qsort(void *base, int nelem, unsigned int width, int ( * pfCompare)( const void *, const void *));

      使用该函数，可以对任何类型的一维数组排序。该函数参数中，base 是待排序数组的起始地址，nelem 是待排序数组的元素个数，width 是待排序数组      的每个元素的大小（以字节为单位），最后一个参数 pfCompare 是一个函数指针，它指向一个“比较函数”。

6.bsearch的用法

void * bsearch(const void * key, const void * base, size_t num, size_t size, int (*comparator) ( const void *, const void * )

采用二分法查找的方法，找到在指定数组中的是否存在需要查找的数据，并返回，

comparator函数用来确定是以什么样的方法来判定是都是想要找的数据，可以自己定制化

比如查找23，现有数据为24,33,24,87，查找各位为3的数字都有哪些？

int compareG3(const void* a,const void* b)

{

unsinged int *p1,*p2;

p1 = (unsigned int *)a;

p2 = (unsigned int *)b;

retrun (%p1%10) -(%p2%10)

}

key =23;

values=[24,33,24,87]

pItem = (int*) bsearch (&key, values, 4, sizeof (int), compareG3);  

pItem则返回23

7.template<int x> Test 用法

c++模板参数有两类，一种是类型，一种是数值。关于数值作为模板参数，template<int x> 这样的模板要如何使用N这个值。一种用途是以int array[N]的方式创建长度为N的数组。如果这个N你让用户以函数参数的方式传入，那么你必须new这个数组，现在你可以在编译时就知道N

下面是非常完整的所有template的用法

Template type parameter:

template<typename T>
struct Container {
    T t;
};


// pass type "long" as argument.
Container<long> test;
Template integer parameter:


template<unsigned int S>
struct Vector {
    unsigned char bytes[S];
};


// pass 3 as argument.
Vector<3> test;
Template pointer parameter (passing a pointer to a function)


template<void (*F)()>
struct FunctionWrapper {
    static void call_it() { F(); }
};


// pass address of function do_it as argument.
void do_it() { }
FunctionWrapper<&do_it> test;
Template reference parameter (passing an integer)


template<int &A>
struct SillyExample {
    static void do_it() { A = 10; }
};


// pass flag as argument
int flag;
SillyExample<flag> test;
Template template parameter.


template<template<typename T> class AllocatePolicy>
struct Pool {
    void allocate(size_t n) {
        int *p = AllocatePolicy<int>::allocate(n);
    }
};


// pass the template "allocator" as argument. 
template<typename T>
struct allocator { static T * allocate(size_t n) { return 0; } };
Pool<allocator> test;
A template without any parameters is not possible. But a template without any explicit argument is possible - it has default arguments:


template<unsigned int SIZE = 3>
struct Vector {
    unsigned char buffer[SIZE];
};


Vector<> test;
Syntactically, template<> is reserved to mark an explicit template specialization, instead of a template without parameters:


template<>
struct Vector<3> {
    // alternative definition for SIZE == 3
};