程序设计基本概念（4） inline, define,指针和引用

关于inline的问题

inline相比define可以做参数的类型检查。define只是简单的替换，无验证。

而inline是将代码直接插入到调用处，减少普通函数调用时的资源的消耗，例如：

inline int fac(float i) {return i * i}; 
printf( "bb= %d", fact(8) );

关于指针和引用的区别

（1）一个引用必须总是指向某些对象。

（2）应用在使用前不需要测试它的合法性。但是指针要防止它是空。

（3）引用的指向不能被改变，但是内容可以改变。指针的指向和指向的内容都可以被改变。

（4）引用和指针的使用原则是，引用不会改变指向，不能为空。指针可以为空，并且可以改变指向。

例如：

int &reiv;

错误：引用必须初始化。

int iv;
int &reiv = iv;

const double di;

错误: const 必须进行初始化赋值。

int *pi;
*pi = 5;

错误： pi没有指向实际的地址。在这种情况下赋值会错误。

*给内存地址“0x123456789”赋值为0，写出代码。

其中unsigned int类型最大值为0xFFFF FFFF,所以上面的地址超出范围。利用unsigned long int,为8个byte,64位。16进制中，有效位为的16位。

unsigned long p*;

p = (long*)0x123456789;

*p = 0;

关于传递动态内存

void GetMemory(char* p, int num)
{
    p = (char*)malloc(sizeof(char)*num);
}

上面的过程实际上对指针首先进行了临时copy，并且申请了内存空间。但是没有传递出去，造成内存泄露。应该把指针的地址传入函数内进行修改。

#include<iostream>

void GetMemory(char** p, int num)
{
  *p = (char*)malloc(sizeof(char)*num); 

};

void main()
{
  char * str = nullptr;
  GetMemory(&str, 100);
  strcpy(str,"hello");

  std::cout << *str <<std::endl;
  std::cout << str << std::endl;
  std::cout << &str << std::endl;
}

上面传入的是指针的指针。并让指针进行改写，让它指向新申请的地址。

char*和char [] 区别

char *c = "abc"和char c[]="abc",前者改变其内容程序是会崩溃的，而后者完全正确。 因为char*c=“abc”分配在字符串常量区。不可以修改。而char c[]=”abc”分配在堆上，可以进行修改。

int* a中a , a[0]和a[1]区别

#include<iostream>

void main()
{
  int* a = new int[10];
  
  std::cout << &a << std::endl;
  std::cout << a << std::endl;
  std::cout << &a[0]  << std::endl;
  std::cout << &a[1]  << std::endl;
}

得到的结果为：

其中，这里保存a的指针在栈上。其中数组保存在堆上，地位为a指针保存的内容。a[0]的地址为首地址。a[1]的地址为a所指向的地址往下平移一个sizeof(int)单元，即为4个byte。

函数指针

函数指针  void (f*)()

函数返回指针 void* f()

const指针   int const*

指向const指针   int* const

指向const的const指针  int  const* const

例：

#include<iostream>

void main()
{
  int max(int, int);
  int (*f)(int, int)=&max;

  int a = 1;
  int b = 2;
  int c = 3;

  std::cout << (*f)((*f)(a,b),c) <<std::endl;
}

int max(int x, int y)
{
    return x>y ? x:y;
};

其中函数的指针定义为 int (*f)(int,int),其中注意(*f)。其中是这个函数指针的函数功能的时候(*f)(1,2)。

long (*f)(int) 为函数指针，输入参数为int, 函数返回值为long。

long* f(int)为返回值为long* 函数，输入参数int.

int(*(*f)(int,int))(int)  其中*(*f)(int, int)为函数指针，输入参数int,int。返回值为指针。指向函数为 int(*F)(int)。

 

一些容易混乱的指针定义

float (*def) [10] 是数组的指针, 数组的元素为float。

float *def[10] 是指针数组，其中数组的元素为float*.

#include<iostream>

void main()
{
    float a[5] ={2,2,3,4,5};
    float (*pa)[5] = &a;
    float *p = &a[0];

    std::cout << a <<std::endl;             // array address
    std::cout << sizeof(a) <<std::endl;     // sizeof array a is 20 byte. 4byte x 5
    std::cout << pa <<std::endl;            // array start address for a[5]
    std::cout << p <<std::endl;             // address for float a[0]
    std::cout <<(*pa)[0] <<"  "<<(*pa)[1] <<std::endl;

    float (**ppa)[5] = &pa;
    std::cout << *ppa <<std::endl;
    std::cout << (**ppa)[0] << "  "<<(**ppa)[1]<<std::endl;
}

其中a为数组的首地址，a[0]访问数组的第一个元素。对于a[5]的指针是float(*pa)[5]。 对于pa的指针定义为float(**ppa)[5], 其中ppa的所指向的数组的内容为**pa[0]。

double*(*gh)[10]; gh是一个指针，所指向的数组为double*, 大小为10。

double(*f[10])(); f[10]为数组，其中数组的内容为函数指针，double(*)(), 函数无输入值，返回为double.

long(*f)()为函数指针。

int(*(*F)(int,int))(int); F是函数指针，函数为（int,int）返回为另一个函数指针，函数为 int (int) 输入为int,且返回int。

 

指针数组和数组指针

1. 数组指针 int(*a)[10]; a++; 数组指针将后平移10 x 4 byte =40 byte.

2.  int(*pr) []: 指向整形数组的指针。

int* pr[]: 指针数组，里面的保存的是地址。地址所指向的值为*pr[0], *pr[1]…

int pr[]: 数组。

int a; // an integer

int *a; // a pointer to an integer

int **a; // a pointer to a pointer to an integer

int a[10]; // an array of 10 integers

int *a[10]; // an array of 10 pointers to integers

int (*a)[10]; // a pointer to an array of 10 integers

int(*a)(int); // a pointer to a function that takes an integer argument and return an integer

int(*a[10])(int); // an array of 10 pointers to functions that takes an integer argument and return an integer

3.

int a[] ={1,2,3,4,5};
int *ptr = (int*)(&a+1);
print("%d %d", *(a+1), *(ptr-1));

其中 a+1为指针操作，平移4type, *(a+1)为2。 （&a+1）表示双指针，或者可以描述二维数组，+1表示数组多一行，为+6个元素。所以*(ptr-1)所指的元素为5。