c++从入门到跑路(1)

此文章主要是为了记录自己和激励自己学习c++。如果有问题不吝赐教。

c++指针

要想成为一名优秀的c++程序员，学习指针是很有必要的
正如你所知道的，每一个变量都有一个内存位置，每一个内存位置都定义了可以使用连子号(&)运算符访问的地址，它表示了在内存中的一个地址。

什么是指针?
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，你必须在使用指针存储其他变量地址前，对其进行声明。指针变量声明的一般形式为

 type *var-name

所有指针的值的实际数据类型，不管是整形，浮点，字符还是其他数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针唯一不同的是，指针所指的变量或者常量的数据类型不同

c++ 中使用指针

使用指针的时候会频繁进行一下操作:定义一个指针变量，把变量地址赋值给指针，访问指针变量中可用地址的值。这些是通过使用一元运算符*来返回位于操作数所指定地址变量的值。

c++ Null指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个NULL值是一个良好的编程习惯。赋为NULL的值的指针被称为空指针。NULL指针是一个定义在标准库中的值为零的常量
检查一个空指针

if（ptr）   /如果ptr费控在，则完成

因此，如果所有未使用的空指针都被赋予空值，同时避免使用空指针，就可以防止误用一个未初始化的指针。很多时候，未初始化的变量存有一些垃圾值，导致程序难以调试

c++指针的算术运算

指针是一个用数值表示的地址。因此，你可以对指针执行算术运算。可以对指针进行 ,++, --, +, -
假设ptr是一个指定地址1000的整数指针，是一个32位的整数，让我们对该指针执行下列算术运算.

ptr++

在执行完上述运算之后，ptr将指向位置1004，因为ptr每次增加一次，它都将指向下一个整数位置，即当前位置往后移4个字节。这个运算会在不影响内存位置中实际位置的情况下，移动指针到一下个内存位置，如果ptr指向一个地址为1000的字符，上面的运算符会导致指针指向1001，因为下一个字符位置是1001

递增一个指针
我们喜欢在程序中使用指针替代数组，因为变量指针可以递增，而数组不能递增，因为数组是一个常量指针。下面的程序递增表里指针，一遍顺序访问数据中的每一个元素

	int var[MAX] = {10,20,30};
	int *ptr;
	//指针中的数组地址
	ptr = var;
	for(int i = 0 ;i < MAX;I++){
		    cout << "Address of var[" << i << "] = ";
      cout << ptr << endl;
 
      cout << "Value of var[" << i << "] = ";
      cout << *ptr << endl;
 
      // 移动到下一个位置
      ptr++;
	}

递减一个指针
与上面代码雷同 只不过用ptr–

指针的比较
指针可以用关系运算符进行比较，如==,<和>。如果p1和p2指向俩个相关的变量，比如同一个数组中的不同元素，则可以对p1和p2进行带下比较。

c++指向指针的指针(多级间接寻址)

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含第二个指针的地址，第二指针指向包含实际值的位置

一个指向指针的指针变量必须如下声明，即在变量名前放置俩个*号。比如如下

int **var;

--------------
int  var;
    int  *ptr;
    int  **pptr;
 
    var = 3000;
 
    // 获取 var 的地址
    ptr = &var;
 
    // 使用运算符 & 获取 ptr 的地址
    pptr = &ptr;
 
    // 使用 pptr 获取值
    cout << "var 值为 :" << var << endl;
    cout << "*ptr 值为:" << *ptr << endl;
    cout << "**pptr 值为:" << **pptr << endl;
 
    return 0;

c++传递指针给函数

c++ 允许你传递指针给函数，只需要简单地声明函数参数为指针类型即可

int main ()
{
   unsigned long sec;
 
 
   getSeconds( &sec );
 
   // 输出实际值
   cout << "Number of seconds :" << sec << endl;
 
   return 0;
}
 
void getSeconds(unsigned long *par)
{
   // 获取当前的秒数
   *par = time( NULL );
   return;
}

能接受指针作为参数的函数，也能接受数组作为参数

double getAverage(int *arr, int size);
 
int main ()
{
   // 带有 5 个元素的整型数组
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;
 
   // 传递一个指向数组的指针作为参数
   avg = getAverage( balance, 5 ) ;
 
   // 输出返回值
   cout << "Average value is: " << avg << endl; 
    
   return 0;
}
 
double getAverage(int *arr, int size)
{
  int    i, sum = 0;       
  double avg;          
 
  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
   }
 
  avg = double(sum) / size;
 
  return avg;
}

c++从函数返回指针

上面已经了解c++中如何从函数返回数组,类似的，c++允许你从函数返回指针。为了到这点，你必须声明一个返回指针的函数

int * myFunction()
{
.
.
.
}

另外，c++不支持在函数外返回局部变量的地址，除非定义局部变量为static变量
现在，让我们看下面的函数，它会生成10个随机数，并使用表示指针的数组名来返回它们

using namespace std;
 
// 要生成和返回随机数的函数
int * getRandom( )
{
  static int  r[10];
 
  // 设置种子
  srand( (unsigned)time( NULL ) );
  for (int i = 0; i < 10; ++i)
  {
    r[i] = rand();
    cout << r[i] << endl;
  }
 
  return r;
}
 
// 要调用上面定义函数的主函数
int main ()
{
   // 一个指向整数的指针
   int *p;
 
   p = getRandom();
   for ( int i = 0; i < 10; i++ )
   {
       cout << "*(p + " << i << ") : ";
       cout << *(p + i) << endl;
   }
 
   return 0;
}

其中p = getRandom（）p获取的是 一个数组的地址，然后用*获取地址的内容。

c++ 引用

引用变量是一个别名，也就说，它是某个已经存在的变量的另一个名字，一旦把引用初始化为某个变量，就可以使用该引用或变量名来指向变量。

c++引用vs指针
引用很容易与指针混淆，他们之间有三个主要的不同

• 不存在空引用。引用必须连接到一块合法的内存
• 一旦引用被初始化为一个对象，就不能被指向到另一个对象，指针可以在任何时候指向另一个对象
• 引用必须在创建时呗初始化，指针可以在任何时间被初始化

c++中创建引用
试想变量名称是变量附属在内存位置中的标签，你可以把引用当成变量附属在内存位置中的第二标签，因此，你可以通过原始变量名称或引用来访问变量的内容 比如

 int i = 19;

我们可以为i声明引用变量 如下

int& r = i;
double& s = d;

在这些声明中，&读作引用，因此，第一个声明可以读作 r是一个初始化为i的整型引用。第二声明可以读作 s是一个初始化为d的double类型引用。下面实例使用了int和doubel引用:

int main ()
{
   // 声明简单的变量
   int    i;
   double d;
 
   // 声明引用变量
   int&    r = i;
   double& s = d;
   
   i = 5;
   cout << "Value of i : " << i << endl;
   cout << "Value of i reference : " << r  << endl;
 
   d = 11.7;
   cout << "Value of d : " << d << endl;
   cout << "Value of d reference : " << s  << endl;
   
   return 0;
}
产生下列结果
Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7

c++把引用作为参数

我们已经讨论了如何使用指针来实现引用调用函数，下面实例使用了引用来实现引用调用函数

// 函数声明
void swap(int& x, int& y);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
 
   cout << "交换前，a 的值：" << a << endl;
   cout << "交换前，b 的值：" << b << endl;
 
   /* 调用函数来交换值 */
   swap(a, b);
 
   cout << "交换后，a 的值：" << a << endl;
   cout << "交换后，b 的值：" << b << endl;
 
   return 0;
}
 
// 函数定义
void swap(int& x, int& y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y  */
  
   return;
}

当上面的代码被编译和执行时，它会产生下列结果
交换前，a 的值： 100
交换前，b 的值： 200
交换后，a 的值： 200
交换后，b 的值： 100

因为a与b叫交换的是地址。

c++把引用作为返回值

通过使用引用来替代指针，会使c++程序更容易阅读和维护。c++函数可以返回一个引用。方式yu返回指针类型

double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};
 
double& setValues( int i )
{
  return vals[i];   // 返回第 i 个元素的引用
}
 
// 要调用上面定义函数的主函数
int main ()
{
 
   cout << "改变前的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
 
   setValues(1) = 20.23; // 改变第 2 个元素
   setValues(3) = 70.8;  // 改变第 4 个元素
 
   cout << "改变后的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
   return 0;
}

改变前的值
vals[0] = 10.1
vals[1] = 12.6
vals[2] = 33.1
vals[3] = 24.1
vals[4] = 50
改变后的值
vals[0] = 10.1
vals[1] = 20.23
vals[2] = 33.1
vals[3] = 70.8
vals[4] = 50

当返回一个引用时，要注意被引用的对象不能超出作用域、所以返回一个局部变量的引用时不合法的，但是可以返回一个对静态变量的引用

int& func() {
   int q;
   //! return q; // 在编译时发生错误
   static int x;
   return x;     // 安全，x 在函数作用域外依然是有效的
}