C-程序设计1

---

title: C++程序设计1
date: 2022-03-30 09:20:55
tags: C++
categories: C++
coverImg:
img:
author: buran
summary: 通过这个系列，希望自己能够仔仔细细把C和C++熟练掌握，为了之后的职业发展！

第一天

简单的C++程序

#include <iostream>
using namespace std;
//可以包含注释代码
int main()
{
    int x, y, sum;
    cout << "请输入两个整数：" << endl;
    cin >> x;
    cin >> y;
    sum = x + y;
    cout << "sum=x+y=" << sum << endl;
}

C++程序的结构特性：

面向对象的程序

• 类的声明部分
• 类的使用部分

运算符">>"允许用户连续输入一连串数据，例如：

cin >> x >> y;

运算符"<<"允许用户连续输出一连串数据，例如：

cout << sum << x << y << endl;

可以输出为十六进制，十进制，八进制等形式。

cout << hex << x << ' ' << dec << x << ' ' << oct << x << ' ' << endl;

结构、联合、枚举。

struct,union,enum;

更灵活更安全的方式定义常量：const。

const int LIMIT = 100;

常量LIMIT是有类型的，占用存储单元，有地址，可以用指针指向它，但不能修改它。

const也可以和指针一起使用，有三种：指向常量的指针，常指针，指向常量的常指针。

    const char* name = "chen";
    //不能改变指针所指的常量，但是可以修改指针的指向
    name = "zou";
    //这句是对的

    char* const name_new = "cheng";
    //理论上是可以的，但是为什么出错了？
    name_new[3] = 'c';

    const char* const name_ano = "li";
    //都不能修改

在C++中，如果函数调用的位置在函数定义之前，则要求在函数调用之前必须对所调用的函数作函数原型声明，以说明函数的名称，参数类型与个数，以及函数返回值的类型。目的是确保C++编译程序检查。

内联函数：在函数说明前冠以关键字"inline"，该函数就被声明为内联函数，又称内置函数。每当程序中出现对该函数的调用时，C++编译器使用函数体中的代码插入到调用该函数语句处，同时用实参取代形参，以便在程序运行时不再进行函数调用。

这是一种用时间换空间的方式，只有简单的函数，并且频繁使用的时候才可能会用，如果函数过于复杂，就算定义为内联函数，但也会转化为普通函数运行。

#include <iostream>
using namespace std;
//声明
inline int box(int i, int j, int k);
//定义
inline int box(int i, int j, int k)
{
    return i * j * k;
}

int main()
{
    int a, b, c;
    cout << "请输入三个整数：a,b,c" << endl;
    cin >> a >> b >> c;
    cout << "输出结果是：" << box(a, b, c) << endl;//使用box函数
    return 0;
}

使用内联函数代替宏定义，就能消除宏定义的不安全性。

#define double1(x) x*2
//正常
double1(2);
double1(5);
//出错
double1(1 + 2);

inline int double2(int x);
inline int double2(int x)
{
    return 2 * x;
}
//正常
double2(1 + 2);

带有默认参数的函数。

函数的重载：只要函数的参数类型不同，或者参数的个数不同，或者两者兼而有之，两个或者两个以上的函数可以使用相同的函数名。当两个或者两个以上的函数公用一个函数名时，称为函数的重载。

//操作数的数据类型不同
#include <iostream>
using namespace std;

//声明函数
int square(int i);
long square(long i);
float square(float i);
//定义函数
int square(int i)
{
	return i * i;
}
long square(long i)
{
	return i * i;
}
float square(float i)
{
	return i * i;
}

int main()
{
	int num1;
	long num2;
	float num3;
	cout << "请输入三个数分别为num1,num2,num3：" << endl;
	cin >> num1 >> num2 >> num3;
	cout << "输出num1的平方：" << square(num1) << endl;
	cout << "输出num2的平方：" << square(num2) << endl;
	cout << "输出num3的平方：" << square(num3) << endl;
	cout << "结束！" << endl;
	return 0;
}

//还有这种变量的数量不同而使用的重载
#include <iostream>
using namespace std;
//声明函数（重载）
int multi(int a, int b);
int multi(int a, int b, int c);

//定义函数
int multi(int a, int b)
{
	return a * b;
}
int multi(int a, int b, int c)
{
	return a * b * c;
}

int main()
{
	//使用重载函数
	int num1, num2,num3;
	cout << "输入num1,num2,num3的值是多少！" << endl;
	cin >> num1 >> num2 >> num3;
	cout << "num1xnum2=" << multi(num1, num2) << endl;
	cout << "num1xnum2xnum3=" << multi(num1, num2, num3) << endl;
	return 0;
}

作用域运算符"::"

通常情况下，如果有两个同名变量，一个是全局的，另一个是局部的，那么局部变量在其作用域内具有较高的优先权，他将屏蔽全局变量。

如果希望在局部变量的作用域内使用同名的全局变量，可以在该变量前加上"::"，此时表示该变量使用的是全局变量的值。

#include <iostream>
using namespace std;
int avar=20;
int main()
{
	int avar;
	avar = 25;
	cout << "局部变量avar：" << avar << endl;
	cout << "全局变量avar：" << ::avar << endl;
	return 0;
}

无名联合。
强制类型转换。

运算符new和delete
删除数组时，使用此方式：

delete []p;//p是指数组的名称即指针变量名

#include <iostream>
using namespace std;

int main()
{
	int* p;
	//p = new int;
	//*p = 10;
	p = new int(10);
	cout << *p << endl;
	cout << *(p + 4) << endl;
	delete p;
	return 0;
}

引用
建立引用的作用是为变量另起一个名字，变量的引用通常被认为是变量的别名。当声明一个引用时，必须同时用另一个变量的名字来将它初始化。即声明它代表哪一个变量，是哪一个变量的别名，这样对一个引用的所有操作，实际上都是对其所代表的变量的操作，就如同对一个人来说，即使有三四个名字，其实是同一个人，用这三四个人所做的事情，其实就是那一个人所做的事情。

#include <iostream>
using namespace std;
//直接利用j变量指示i变量，两者其实是一个地址空间
int main()
{
	int i;
	int& j = i;
	i = 30;
	cout << "i=" << i << " " << "j=" << j << endl;
	j = 80;
	cout << "i=" << i << " " << "j=" << j << endl;
	cout << "变量i的地址：" << &i << endl;
	cout << "变量j的地址：" << &j << endl;
	return 0;
}

#include <iostream>
using namespace std;
//两中方式都挺好（引用和指针）
int main()
{
	int i = 15;
	//直接将i的地址赋给iptr
	int* iptr = &i;
	//用rptr引用i（iptr和i表示的是一个空间）
	int& rptr = i;
	cout << "i is " << i << endl;
	cout << "iptr is " << *iptr << endl;
	cout << "rptr is " << rptr << endl;
	//尝试更改一个地址中的值即可
	i = 39;
	cout << "i is " << i << endl;
	cout << "iptr is " << *iptr << endl;
	cout << "rptr is " << rptr << endl;
	return 0;
}

引用作为函数参数
下面两种方法得到的效果是一样的，需要熟练掌握。

#include <iostream>
using namespace std;

void swap(int* p, int* q);
//这里的p，q是指针类型的整型，即是地址值
void swap(int* p, int* q)
{
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}
int main()
{
	int a = 5, b = 10;
	cout << "a=" << a << " " << "b=" << b << endl;
	swap(&a, &b);
	//交换
	cout << "a=" << a << " " << "b=" << b << endl;
	return 0;
}

//实际上这种方式比较常用，安全性较高并且，比较容易编写
#include <iostream>
using namespace std;

void swap(int& p, int& q);
//这里的p，q都是整型变量
void swap(int& p, int& q)
{
	int temp = p;
	p = q;
	q = temp;
}
int main()
{
	int a = 5, b = 10;
	cout << "a=" << a << " " << "b=" << b << endl;
	swap(a, b);
	//交换
	cout << "a=" << a << " " << "b=" << b << endl;
	return 0;
}

使用引用返回函数值。
这个感觉有点难想，到底这个函数返回的是一个整型。

#include <iostream>
using namespace std;

int a[] = { 1,3,5,7,9 };
int& index(int i);

int& index(int i)
{
	return a[i];
}

int main()
{
	index(2) = 25;
	cout << index(2) << endl;
	return 0;
}

虽然第一章的学习结束了，但是还有很多没搞懂的地方，之后学习应该会花费更多时间去学习！