C++的学习之路＜期末考试版＞

简单示例：

#include <iostream>
using namespace std;
 
// main() 是程序开始执行的地方
 
int main()
{
   cout << "Hello World"; // 输出 Hello World
   return 0;
}

还记得C语言使用的是 printf

对比一下：

C++ 语言定义了一些头文件，这些头文件包含了程序中必需的或有用的信息。上面这段程序中，包含了头文件 <iostream>。
	下一行 using namespace std; 告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念。
	下一行 // main() 是程序开始执行的地方 是一个单行注释。单行注释以 // 开头，在行末结束。
	下一行 int main() 是主函数，程序从这里开始执行。
	下一行 cout << "Hello World"; 会在屏幕上显示消息 "Hello World"。
	下一行 return 0; 终止 main( )函数，并向调用进程返回值 0。

c++有常变量的概念：

const int a = 5; //a的值只能是5

c++函数的使用：

#include <iostream>
using namespace std;
 
// 函数声明
int max(int num1, int num2);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
   int ret;
 
   // 调用函数来获取最大值
   ret = max(a, b);
 
   cout << "Max value is : " << ret << endl;
 
   return 0;
}
 
// 函数返回两个数中较大的那个数
int max(int num1, int num2) 
{
   // 局部变量声明
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

//c++新增加的东西
int i;
float f;
cin >> i;
cout << f;
------------
scanf("%d", &i);
printf("%f", f);
----------------
连续读入
cin >> a >> b >> c;

各个指针的区别：

const int constantValue = 10;
int nonConstantValue = 20;

const int* ptrToConstant = &constantValue; // 指向常量的指针
ptrToConstant = &nonConstantValue; // 合法

*ptrToConstant = 30; // 非法，不能修改指向的常量值

nt value = 10;
int* const constantPtr = &value; // 常指针
*constantPtr = 20; // 合法，可以修改指针所指向的值

int anotherValue = 30;
constantPtr = &anotherValue; // 非法，无法修改指针的指向

const int constantValue = 10;
int nonConstantValue = 20;

const int* const constantPtrToConstant = &constantValue; // 指向常量的常指针
*constantPtrToConstant = 30; // 非法，不能修改指向的常量值
constantPtrToConstant = &nonConstantValue; // 非法，不能修改指针的指向

内联函数：

inline关键词引用，是为了降低系统的开销，提高系统的运行速度：
说明：

内联函数在第一次被调用之前必须进行完整的定义，否则编译器将无法知道应该插入什么代码
在内联函数体内一般不能含有复杂的控制语句，如for语句和switch语句等
使用内联函数是一种空间换时间的措施，若内联函数较长，较复杂且调用较为频繁时不建议使用

实例：

#include <iostream>

// 内联函数声明
inline int Add(int a, int b) {
    return a + b;
}

int main() {
    int num1 = 5;
    int num2 = 7;

    // 调用内联函数
    int sum = Add(num1, num2);

    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

函数的默认值的问题：

void init(int x = 5, int y = 10);
init (100, 19);   // 100 ， 19
init(25);         // 25, 10
init();           // 5， 10

在函数原型中，所有取默认值的参数都必须出现在不取默认值的参数的右边。

如    int fun(int a, int b, int c = 666);

函数重载：

#include <iostream>
using namespace std;

int add(int x, int y)
{
	return x + y;
}

double add(double x, double y)
{
	return x + y;
}

int add(int x, int y, int z)
{
	return x + y + z;
}

int main() 
{
	int a = 3, b = 5, c = 7;
	double x = 10.334, y = 8.9003;
	cout << add(a, b) << endl;
	cout << add(x, y) << endl;
	cout << add(a, b, c) << endl;
	return 0;
}
//同一函数名不同的形参使用

作用域标识符：

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

如果希望在局部变量的作用域内使用同名的全局变量，可以在该变量前加上“::”，此时::value代表全局变量value，“::”称为作用域标识符。

#include <iostream>
using namespace std;

int value;   //定义全局变量value

int main() 
{
	int value;  //定义局部变量value
	value = 100;
	::value = 1000;
	cout << "local value : " << value << endl;
	cout << "global value : " << ::value << endl;
	return 0;
}

强制类型转换：

int i = 10;
double x = (double)i;
或
int i = 10;
double x = double(i);

new/delete

指针变量名 = new 类型
    int *p;
    p = new int;
delete 指针变量名
    delete p;

使用运算符new可以为数组动态分配内存空间，这时需要在类型后面加上数组大小。

指针变量名 = new 类型名[下标表达式];
int *p = new int[10];

引用：

类型 &引用名 = 已定义的变量名

#include <iostream>
using namespace std;
int main() 
{
	int i = 10;
	int &j = i;
	cout << "i = " << i << " j = " << j << endl;
	cout << "i的地址为 " << &i << endl;
	cout << "j的地址为 " << &j << endl;
	return 0;
}
//i j 的地址一样

引用作为函数参数：

#include <iostream>
using namespace std;

void swap(int &a, int &b)
{
	int t = a;
	a = b;
	b = t;
}

int a[] = {1, 3, 5, 7, 9};

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

int main() 
{
	int a = 5, b = 10;
	//交换数字a和b
	swap(a, b);
	cout << "a = " << a << " b = " << b << endl;
	cout << index(2) << endl;   //等价于输出元素a[2]的值
	index(2) = 100;             //等价于将a[2]的值赋为100;
	cout << index(2) << endl;
	
	return 0;
}

不允许建立void类型的引用
不能建立引用的数组
不能建立引用的引用。不能建立指向引用的指针。引用本身不是一种数据类型，所以没有引用的引用，也没有引用的指针。
可以将引用的地址赋值给一个指针，此时指针指向的是原来的变量。
可以用const对引用加以限定，不允许改变该引用的值，但是它不阻止引用所代表的变量的值。

类：

class 类名{
    public：
        公有数据成员；
        公有成员函数；
    protected:
        保护数据成员；
        保护成员函数；
    private:
        私有数据成员；
        私有成员函数；
};

类中成员函数的定义：

class Score{
public:
	void setScore(int m, int f);
	void showScore();
private:
	int mid_exam;
	int fin_exam;
};

void Score::setScore(int m, int f) 
{
	mid_exam = m;
	fin_exam = f;
}

void Score::showScore()
{
	cout << "期中成绩: " << mid_exam << endl;
	cout << "期末成绩：" << fin_exam << endl;
}