第七章 指针、数组与引用

函数指针:

#include <iostream>
#include <cstdint>
#include <string.h>
#include <vector>
int a_function(char* a ){
    return 1;
}
int main() {
    char c='a';
    char*p=&c;
    int (*f)(char*)=a_function;  //指向函数的指针，该函数接受一个char*类型实参，返回一个int
    int k=(*f)(p);
    std::cout<<k<<std::endl;
}

 

void*：

#include <iostream>

int main() {
    int p=2;
    void* a=&p;
    void* b=&p;
    void* c=b;   //可以赋值
    int* d= static_cast<int *>(c); //可以显式的转换。
    if(a==b)    //可以比较
        std::cout << "Hello, World!" << std::endl;
    std::cout << *d << std::endl;
    return 0;
}

1、不可以指向函数指针和指向类成员的指针
2、若要进行其它操作，首先需要进行显示转化。
3、主要用于无法确定类型时，向函数传递某对象的指针，从函数返回未知类型是对象。

 

在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区： 

栈：就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

堆：就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
 
    堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。 
    栈在程序中是应用最广泛 的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。

自由存储区：就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
    int *p;
　　p = (int*)malloc(sizeof(int) * 128);
　　　　//分配128个整型存储单元，并将这128个连续的整型存储单元的首地址存储到指针变量p中
　　double *pd = (double*)malloc(sizeof(double) * 12);　　
　　　　//分配12个double型存储单元，并将首地址存储到指针变量pd中
　　free(p);
　　free(pd);
　　p = NULL;
　　pd = NULL;　　
　　指针用完赋值NULL是一个很好的习惯。 
全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。 

常量存储区：这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多，在《const的思考》一文中，我给出了6种方法） 明确区分堆与栈 

一个由c/C++编译的程序占用的内存分为以下几个部分 ：
    1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 
    2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 
    3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
    4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放 
    5、程序代码区—存放函数体的二进制代码。

    int a = 0; 全局初始化区 
    char *p1; 全局未初始化区 
    main() 
    { 
    int b; 栈 
    char s[] = "abc"; 栈 
    char *p2; 栈 
    char *p3 = "123456"; 123456在常量区，p3在栈上。 
    static int c =0； 全局（静态）初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); 
    分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); 123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地        方。 
    }

数组：
数组不能执行赋值操作，需要的话，数组名就会变为指向数组首元素的指针。
在接口中不允许使用数组。


以0作为终止符的char数组是应用最广泛的一种数组。
int v[6]={1,2,3,4};等同于int v[6] = {1,2,3,4,0,0}


数组不支持赋值操作，所以不允许以值方式传递数组。
strcat(字符数组1，字符数组2)
strcat的作用是连接两个字符数组中的字符串，把字符串2接到字符串1的后面，结果放在字符数组1中，函数调用后得到一个函数值——字符数组1的地址。
#include <iostream>
#include <string.h>
int main() {
    char str1[30] = {"People's Republic of "};
    char str2[] ={"China"};
//    char* a = strcat(str1,str2);
   std::cout<<strcat(str1,str2)<<std::endl;

}


strcpy(字符数组1，字符串2)
strcpy是“字符串复制函数”。
作用:是将字符串2复制到字符数组1中去。例如：
char str1［10］，str2［］={″China″};
strcpy(str1，”china”);
（1） 字符数组1必须定义得足够大，以便容纳被复制的字符串。字符数组1的长度不应小于字符串2的长度。

（2） “字符数组1”必须写成数组名形式(如str1)，“字符串2”可以是字符数组名，也可以是一个字符串常量。如：strcpy(str1，″China″)； 
（3） 复制时连同字符串后面的′＼0′一起复制到字符数组1中。
（4） 可以用strncpy函数将字符串2中前面若干个字符复制到字符数组1中去。
      例如:strncpy(str1，str2，2);作用是将str2中前面2个字符复制到str1中去，然后再加一个‘＼0’。

（5） 不能用赋值语句将一个字符串常量或字符数组直接给一个字符数组。如：
      str1=″China″;  不合法    
      str1=str2;       不合法
用strcpy函数只能将一个字符串复制到另一个字符数组中去。
用赋值语句只能将一个字符赋给一个字符型变量或字符数组元素。
下面是合法的使用:
char a［5］，c1，c2; 
c1=′A′;  c2=′B′;
a［0］=′C′; a［1］=′h′; a［2］=′i′; 
a［3］=′n′; a［4］=′a′; 


 strcmp函数
其一般形式为：strcmp(字符串1，字符串2)
strcmp的作用是比较字符串1和字符串2。
例如：strcmp(str1，str2);
          strcmp(″China″，″Korea″);
          strcmp(str1，″Beijing″);
比较的结果由函数值带回
(1) 如果字符串1=字符串2，函数值为0。
(2) 如果字符串1>字符串2，函数值为一正整数。
(3) 如果字符串1<字符串2，函数值为一负整数。
注意：对两个字符串比较，不能用以下形式：
if(str1>str2) 
printf(″yes″);
而只能用
if(strcmp(str1，str2)>0) 
printf(″yes″)。


memcpy函数：
#include <iostream>
#include <string.h>
struct {
    char name[40];
    int age;
} person, person_copy;

int main()
{
    char myname[] = "Pierre de Fermat";
    /* using memcpy to copy string: */
    std::cout<<strlen(myname)<<std::endl;
    memcpy(person.name, myname, strlen(myname)+1);
    person.age = 46;
    std::cout<<person.name<<std::endl;
    std::cout<<person.age<<std::endl;
    /* using memcpy to copy structure: */
    memcpy(&person_copy, &person, sizeof(person));
    std::cout<<person_copy.name<<std::endl;
    std::cout<<person_copy.age<<std::endl;
    return 0;
}

 valarray：

Operators

operator!	A unary operator that obtains the logical NOT values of each element in a valarray.
operator%=	Obtains the remainder of dividing the elements of an array element-wise either by a specified valarray or by a value of the element type.
operator&=	Obtains the bitwise AND of elements in an array either with the corresponding elements in a specified valarray or with a value of the element type.
operator>>=	Right-shifts the bits for each element of a valarray operand a specified number of positions or by an element-wise amount specified by a second valarray.
operator<<=	Left-shifts the bits for each element of a valarray operand a specified number of positions or by an element-wise amount specified by a second valarray.
operator*=	Multiplies the elements of a specified valarray or a value of the element type, element-wise, to an operand valarray.
operator+	A unary operator that applies a plus to each element in a valarray.
operator+=	Adds the elements of a specified valarray or a value of the element type, element-wise, to an operand valarray.
operator-	A unary operator that applies a minus to each element in a valarray.
operator-=	Subtracts the elements of a specified valarray or a value of the element type, element-wise, from an operand valarray.
operator/=	Divides an operand valarray element-wise by the elements of a specified valarray or a value of the element type.
operator=	Assigns elements to a valarray whose values are specified either directly or as part of some other valarray or by a slice_array, gslice_array, mask_array, or indirect_array.
operator[]	Returns a reference to an element or its value at specified index or a specified subset.
operator^=	Obtains the element-wise exclusive logical or operator (XOR) of an array with either a specified valarray or a value of the element type.
operator|=	Obtains the bitwise OR of elements in an array either with the corresponding elements in a specified valarray or with a value of the element type.
operator~	A unary operator that obtains the bitwise NOT values of each element in a valarray.

valarray：
#include <iostream>
#include <string.h>
#include <valarray>
int main()
{
    int i;
    std::valarray<int> va(20),vb(20);
    for ( i = 0 ; i < 20 ; i+=1 )
        va [ i ] = - 2 * (i + 1 );
    std::cout << "The operand valarray va is:\n( ";
    for ( i = 0 ; i < 20 ; i++ )
        std::cout << va [ i ] << " ";
    std::cout << ")." << std::endl;
    //-----------------------------valarray类的公有接口如下----------------------------------
    //apply-------将指定的函数应用于valarray的每个元素。--------------------------------------
    //cshift------循环地将一个valarray中的所有元素移动指定数量的位置。-------------------------
    //shift-------将valarray中的所有元素移动指定数量的位置。----------------------------------
    //max---------查找valarray中最大的元素。-------------------------------------------------
    //min---------查找valarray中的最小元素。-------------------------------------------------
    //resize------将valarray中的元素数量更改为指定的数量，根据需要添加或删除元素。-------------
    //size--------查找一个valarray中的元素数量。---------------------------------------------
    //sum---------确定非零长度值数组中所有元素的和。------------------------------------------


    //apply-------将指定的函数应用于valarray的每个元素。
    // (1.abs 对数组的每一个元素取绝对值
    //  2.acos 返回每个元素的反余弦值
    //  3.asin 返回每个元素的反正弦值
    //  4.atan 返回每个元素的正切值
    //  5.atan2 笛卡尔正切值
    //  6.cos 余弦值
    //  7.cosh 双曲线余弦值
    //  8.exp 返回自然指数E^x
    //  9.log 返回自然对数
    //  10.log10 返回以10为底的返回自然对数
    //  11.exp 返回x^y
    //  12.sin 正弦值
    //  13.sinh 双曲线正弦值
    //  14.sqrt 开方
    //  15.tan 正切值
    //  16.tanh 反正切）
    va=va.apply(abs);
    std::cout << "The operand valarray va is:\n( ";
    for ( i = 0 ; i < 20 ; i++ )
        std::cout << va [ i ] << " ";
    std::cout << ")." << std::endl;

    //cshift------循环地将一个valarray中的所有元素移动指定数量的位置。
    vb = va.cshift(4);
    std::cout << "The operand valarray va is:\n( ";
    for ( i = 0 ; i < 20 ; i++ )
        std::cout << vb [ i ] << " ";
    std::cout << ")." << std::endl;

    vb = va.cshift(-4);
    std::cout << "The operand valarray va is:\n( ";
    for ( i = 0 ; i < 20 ; i++ )
        std::cout << vb [ i ] << " ";
    std::cout << ")." << std::endl;


    //shift-------将valarray中的所有元素移动指定数量的位置。
    vb = va.shift(4);
    std::cout << "The operand valarray va is:\n( ";
    for ( i = 0 ; i < 20 ; i++ )
        std::cout << vb [ i ] << " ";
    std::cout << ")." << std::endl;

    vb = va.shift(-4);
    std::cout << "The operand valarray va is:\n( ";
    for ( i = 0 ; i < 20 ; i++ )
        std::cout << vb [ i ] << " ";
    std::cout << ")." << std::endl;

    //max---------查找valarray中最大的元素。
    std::cout << "valarray中最大的元素" <<va.max()<< std::endl;

    //min---------查找valarray中的最小元素。
    std::cout << "valarray中最小的元素" <<va.min()<< std::endl;

    //resize------将valarray中的元素数量更改为指定的数量，根据需要添加或删除元素。
    vb.resize(8,0);
    std::cout << "The operand valarray va is:\n( ";
    for ( i = 0 ; i < 8 ; i++ )
        std::cout << vb [ i ] << " ";
    std::cout << ")." << std::endl;

    //size--------查找一个valarray中的元素数量。
    std::cout << "valarray中的元素数量" <<va.size()<< std::endl;

    //sum---------确定非零长度值数组中所有元素的和。
    std::cout << "确定非零长度值数组中所有元素的和" <<va.sum()<< std::endl;



     //Gslice类用法与slice类用法
    //Gslice类的用法和slice基本相同，只是它截取的是循环子串，当母串进行一次提取后的字串元素数目达不到要求时，gslice会将提取后的母串继续组合进行提取直到满足要求或者母串被提取完了
//    std::valarray<int>  vaResult(va[std::slice(1, 1, 3)]);
    std::valarray<int>  vaResult(3);
    std::slice vaSlice ( 1 , 3 , 3 );
    vaResult = va [ vaSlice ];
    std::cout << "\nThe slice of valarray va is vaResult:"
         << "\nva[slice( 1, 7, 3)] = ( ";
    for ( i = 0 ; i < 3 ; i++ )
        std::cout << vaResult [ i ] << " ";
    std::cout << ")." << std::endl;



    return 0;
}

789