【学习笔记】C++

声明

本文章非原创，所有内容均来自于实际课堂课件的文本和代码，如有侵权，请联系删除。

一、基础知识

1.cout和cin

使用案例如下：

#include <iostream>
using namespace std;
int main()
{
int i;
char c;
float f;
cout << "type i = "; cin >> i;
cout << "type c = "; cin >> c;
cout << "type f = "; cin >> f;
cout << "i = " << i << endl << "c = " << c << endl << "f = " << f << endl;
return 0;
}

对于cin的使用，有如下几点说明：

1. cin为缓冲流。键盘输入的数据保存在缓冲区中，cin实际上是从缓冲区中提取数据。如果一次性输入过多，会滞留在输入缓冲区中，影响下一次的输入；
2. 输入的数据类型必须与要提取的数据类型一致，否则出错；
3. 空格和回车都可以作为数据之间的分隔符，多个数据可以在一行内输入，也可以分行输入；
4. 对于字符型数据和字符串，空格(ASCII码为32)无法用cin输入，字符串中也不能有空格；回车符也无法读入。

2.作用域限定符::

作用域限定符的格式为限定符::成员名
作用域限定符主要用于类成员的访问及定义，用于说明某一成员属于哪个类。限定符也可以省略，此时说明后面的成员是一个全局变量。

使用案例如下：

#include <iostream>
using namespace std;
int i = 5;
void fun()
{
int i = 20;
cout << "Local variable i = " << i << endl;
//访问局部变量i
cout << "Globa variable i = " << ::i << endl;	//访问全局变量i
}
int main(void)
{
fun();
return 0;
}

显示结果如下：

Local variable i = 20
Globa variable i = 5

3.强制类型转换与const标识符

C++在C语言的基础上增加了一种新的强制类型转换形式，即：

int i = 10;
char c = (char) i;

或

char c = char (i);

const在使用过程中需要注意以下两个问题：

1. 敞亮在定义时必须初始化；
2. const的结合性为右结合，但若是简单数据类型，const也可以写在数据类型的左侧。如：const int i = 5;或int const i = 5;。

C++中，const修饰函数的形式参数，这意味着相应的实际参数在该函数内为常量，不允许在函数内被修改。

4.内联函数incline

C++提供内联函数来减少函数调用所带来的的开销，即将函数的代码嵌入到每一个调用处，虽然会使得程序变得更长，但是可以避免反复调用函数。

内联函数incline的作用类似于宏定义define。下面是使用案例：

#include <iostream>
using namespace std;
inline int Add(int x, int y)
{
return x * y;
}
int main(void)
{
for (int i = 0; i < 10; i++)
{
cout << Add(i, i) << endl;
}
}

输出结果如下：

0
1
4
9
16
25
36
49
64
81

5.函数重载

C++允许在相同作用域中用统一函数名去定义多个函数，这些函数在参数的类型、个数或顺序方面不尽相同。编译器会根据实参和形参的最佳匹配来确定调用哪一个函数。

下面是使用案例：

#include <iostream>
using namespace std;
int Max(int a, int b) {
if (b > a) return b;
else return a;
}
float Max(float a, float b, float c) {
if (b > a) a = b;
if (c > a) a = c;
return a;
}
int main(void)
{
int a, b;
float d, e, f;
cin >> a >> b;
cin >> d >> e >> f;
int max_1 = Max(a, b);
float max_2 = Max(d, e, f);
cout << "max_1 = " << max_1 << endl << "max_2 = " << max_2 << endl;
}

输出结果如下：

1 2
3.5 5.2 8.9
max_1 = 2
max_2 = 8.9

6.引用

引用时C++新增加的一种数据类型。是一个变量起另外一个名字，以便在需要时可以间接地引用该变量。

对一个变量的应用所做的所有操作，都是最该变量本身进行操作。

引用的运算符使用&，用法是<类型标识符> & <引用名> = <变量名>。

比如：

int i = 0;
int& j = i; //声明j是变量i的引用

引用变量j其实就是变量i的另一个名字，对j所做的所有操作其本质上是对i的操作。

请注意，在上述声明中，&代表引用符号，而不是取址符。

关于应用，有以下几个需要注意的地方：

1. 引用在声明之前必须初始化；
2. 引用变量一经初始化后，就不能再去应用别的变量(要从一而终)；
3. 运算符&只有在其前面有类型符时才表示引用，否则表示取址；
4. 系统不会为变量的引用另外分配存储空间，引用和被引用的变量共享同一内存单元。

下面是用法实例：

#include<iostream>
using namespace std;
int main(void)
{
int i = 10;
int& j = i;
cout << "i = " << i << endl;
cout << "j = " << j << endl;
j++;
i++;
cout << "i = " << i << endl;
cout << "j = " << j << endl;
}

输出结果如下：

i = 10
j = 10
i = 12
j = 12

7.new和delete操作符

new和delete与C语言中的malloc()和free()类似，是动态内存的分配和释放。

(1)new操作符

格式如下：

• 指针变量 = new 类型;
• 指针变量 = new 类型(初值);
• 指针变量 = new 类型[数组元素数];

new的返回值：若是非数组类型，返回指向该类型对象的指针了若是数组类型，返回数组的首地址。

使用new操作符时有几点注意事项：

1. new申请动态内存，不一定总会成功，不成功(内存不足)时返回NULL。程序应该注意判断new的返回值，只有在非NULL的情况下才能进行内存访问，例如：

int* p;
p = new int;
if (p != NULL)
{
//正常读写
}
else
{
//内存不够的处理
}

2. new为数组申请动态内存时无法提供初值，请自己赋值；
3. new为二维数组分配动态内存可按照下列方式进行：

int m = 5;
int n = 4;
int** p;	//二维数组
p = new int* [m];
//第一维，即分配m行
for (int i = 0; i < m; i++)
{
p[i] = new int[n];	//第二维，即分配n列
}

(2)delete操作符

delete操作符的格式为：

1. delete 指针变量，释放指针变量所指向的动态内存；
2. delete []指针变量，释放为数组分配的动态内训。

例如：

delete	p;
delete[]p;
for (i = 0; i < m; i++)	//二维数组动态内存释放
{
delete[] p[i];
}

注意，new申请的动态内存在用完后必须用delete释放。

Hello, world

#include <iostream>
using namespace std;
int main(void)	//主函数
{
cout << "Hello, world" << endl;
return 0;
}

输出结果：

Hello, world

二、C++类和对象

1.类的定义

类的一般定义格式如下

class <类名>
{
public:
<成员函数或数据成员的声明>
private:
<数据成员或成员函数的声明>
};
<各个成员函数的类外实现>

关于类的定义的注意事项：

1. 数据成员一般是私有成员，因为类的数据类型必须是封装的；
2. 成员函数一般被声明为公有成员；因为它们提供对外界的操作接口，便于外界访问和使用相应的功能；
3. 关键字public、private和protected被称为访问控制符，用来说明类成员的访问权限；
4. <各个成员函数的类外实现>是类的实现部分，即类中声明的成员函数的代码实现。

下面是使用实例：

//文件路径名为：标头.h
#pragma once
#include <iostream>
using namespace std;
class Date {
public:
void SetDate(int y, int m, int d)	//日期类的行为：设置当前日期的年、月、日
{
year = y;
month = m;
day = d;
}
int IsLeapYear()	//日期类的行为：判断当前日期是否是闰年
{
return(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
void Print()
{
cout << year << "年" << month << "月" << day << "日";
}
private:
int year, month, day;
};

//文件路径名为：源.cpp
#include "标头.h"
int main(void)
{
Date D1;
D1.SetDate(2022, 3, 9);
D1.Print();
cout << "此年是闰年吗？";
if (D1.IsLeapYear())
{
cout << "是。";
}
else
{
cout << "不是。";
}
cout << endl;
}

2.成员函数的实现

(1)类内实现

每一个成员函数在声明时就定义了实现代码，这种形式就叫成员函数在类内实现。如上例，就是类内实现。

(2)类外实现

把成员函数的实现代码放到类外去，类的声明部分就只包含数据成员的声明和成员函数原型的声明。

3.对象的创建

对象是类的实例，语法格式为类名 对象名。如果类的构造函数有参数，那么创建对象时还需提供实参，例如，在定义了Date类之后，可以通过以下代码来创建一个名为newDate的日期对象：

Date newDate;

也可以在一行代码中创建多个对象：

Date newDate1, newDate2, newDate3;

创建对象的代码写在main(void)函数里。

4.类成员的访问

(1)类成员的一般访问形式

当建立一个普通对象时，可以通过对象名和句点符号去访问类的公有成员，相关的语法格式如下：

对象名.数据成员名
//
访问数据成员
对象名.成员函数名(参数表)
//
访问成员函数

(2)类成员的访问权限

面向对象程序设计的一个重要特性就是数据保护。为此，C++专门设置了三种类成员的访问控制符，分别代表三种访问权限，它们是public、private和protected。

public

代表公有的访问权限。它修饰了类对外界公开的部分，凡是由关键字public声明的成员，被称为公有成员，类外允许访问。

private

代表私有的访问权限。它规定了只能被类内部的成员函数访问的部分，而来自类外的任何访问都是非法的。关键字private就像一道屏障，把它所修饰的成员与外界隔开，实现数据隐藏，在最大程度上保护了类的私有数据。

protected

代表保护的访问权限。它与私有的访问权限类似，区别仅在于派生类中。保护权限的成员可以被所在类的派生类成员函数访问；而这一点对于私有成员来说是非法的。

类在声明它的成员时，不同访问权限的成员可以按任意顺序出现。如果私有成员在类的最前面声明，可以省略关键字private，因为它是缺省的访问控制符。

请注意，类的成员函数可以访问类中的所有成员，没有任何限制；而由类创建的对象就不同了。对象往往在类以外的地方比如main函数中被创建，因此它是类外的部分，当它去访问本类成员时将受到访问控制符的限制，不能访问类中的私有成员和保护成员。

下面是类成员访问的实例：

//标头.h
#pragma once
#include <iostream>
using namespace std;
class CDemo {
public:
void SetI(int a) { i = a; }
void SetJ(int b) { j = b; }
void GetI() { cout << "i=" << i << endl; }
void GetJ() { cout << "j=" << j << endl; }
protected:
int j;
private:
int i;	//此处的protected和private暂时看成是一样的功能
};

//源.cpp
#include "标头.h"
int main(void)
{
CDemo d;	//类创建一个CDemo对象d
//d.i = 10;	非法访问
//d.j = 20;	非法访问
d.SetI(2019);
d.SetJ(2022);
d.GetI();
d.GetJ();
return 0;
}

5.构造函数和析构函数

构造函数的作用就是在对象被创建时为其分配内存空间，利用给定的值去初始化对象的数据成员，把对象构造成一个特定的状态。

声明一个构造函数的格式如下：

public:
类名(参数表);

构造函数是类的一个特殊成员函数，它的函数名与类名相同，可以有任意类型的参数，但不具有返回类型。当创建一个新对象时，系统会自动调用构造函数。

下面是构造函数的举例：

//date.h
#pragma once
#include <iostream>
using namespace std;
class Date {
public:
Date();	//构造函数，没有返回值
void SetDate(int y, int m, int d);
void Print();
private:
int year, month, day;
};

//date.cpp
#include "date.h"
Date::Date() {
year = 2000;
month = 1;
day = 1;
}
void Date::SetDate(int y, int m, int d) {
year = y;
month = m;
day = d;
}
void Date::Print() {
cout << year << "年" << month << "月" << day << "日";
}

//main.cpp
#include "date.h"
int main()
{
Date newDate;
newDate.Print();
return 0;
}

注意：以上三段代码是类外实现。
输出的结果如下：

2000年1月1日

最后

以上就是快乐冬日为你收集整理的【学习笔记】C++【学习笔记】C++的全部内容，希望文章能够帮你解决【学习笔记】C++【学习笔记】C++所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。