基础知识
一 C++的结构特性
~~~~~~ 一个面向对象的c++程序一般由类的声明和类的使用量大部分组成。
#include<iostream> // 编译预处理命令
using namespace std; // 使用命名空间std
// 类的声明部分
class A // 声明一个类，类名为A
{
private：
int x, y, z; // 声明类A的数据成员
...
public：
fun(){...} // 声明类A的数据函数
...
};
// 类的使用部分
int main()
{
A a; // 定义类A的一个对象a
...
a.fun(); // 调用对象a的成员函数fun
return 0;
}
二. C++在非面向对象方面对C的扩充
1. 注释行
x = y + z; /* this is a comment */
x = y + z; // this is a comment
2. C++ 的输入和输出
// 标准输入流对象 cin
cin >> a >> b >> c;
// 标准输出流对象 cout
cout << a << b << c << endl;
// 设置域宽的操纵符setw(n)
3. const修饰符
~~~~~ 使用const来定义常量
// const float PI = 3.14 常量PI是类型化的，可以用指针指向它，但不能修改它
// define T1 a+a;define T2 T1-T1;解析后T2 = a+a-a+a
/**
const 与 指针一起使用：
（1）指向常量的指针：一个指向常量的指针变量
const char* pc = "abcd" //声明一个名为pc的指针变量，它指向一个字符型常量，初始化pc为指向字符串"abcd"
pc[3] = "x" // [X] 不允许改变指针所指的常量
pc = "efgh" // [V] 赋值给指针另一个字符串的地址
（2）常指针：把指针变量所指的地址，而不是它所指向的对象声明为常量（创建一个不能移动的指针，不能改变指针所指的地址，但是可以改变数据）
char* const pc = "abcd" // 声明一个名为pc的指针变量，该指针是指向字符型数据的常指针，用字符串abcd来初始化
pc[3] = 'x' // [X]，可以改变常指针pc所指地址中的数据
pc = "efgh" // [V]，不能改变常指针所指的地址
（3）指向常量的常指针：指针所指向的地址和地址中的数据均不能改动
const char* const pc = "abcd"
pc[3] = 'x' // [X]
pc = "efgh" // [X]
**/
4. void型指针
~~~~~~ void通常表示无值，但讲void作为指针的类型时，它却表示为不确定的类型。
5. 内联函数
/**
关键字：inline
原理：编译器使用函数体中的代码插入到调用该函数的语句处，同时用实参取代形参，程序运行时不再进行函数调用
原因：消除函数调用时的系统开销，提高运行速度；消除宏定义的不安全性
注意：
a. 内联函数在第一次调用前必须进行完整的定义
b. 内联函数内一般不含有复杂的控制语句，如for语句和switch语句
**/
#include <iostream>
using namespace std;
inline double circle(double r) // 内联函数
{
return 3.1416 * r * r;
}
int main()
{
for(int i = 1; i <= 3; i ++)
cout << "r=" << i << " area= " << circle(i) << endl;
return 0;
}
结果如下：
r=1 area= 3.1416
r=2 area= 12.5664
r=3 area= 28.2774
6. 带有默认参数值的函数
/**
C++允许实参个数和形参个数不同
说明：在函数原型中，所有取默认值的参数都必须出现在不取默认值的参数的右边，例如
int fun(int i, int j = 5, int k); [X]
int fun(int i, int k, int j = 5);
**/
7. 函数的重载
/**
定义：在同一作用域内，只要函数参数的类型不同，或者参数的个数不同，或者二者兼而有之
说明：
a. 调用重载函数时，函数的返回值类型不在参数匹配检查之列。
b. 函数的重载与带默认值的函数一起使用时，有可能引起二义性
c. 在函数调用时，如果给出的实参和形参类型不相符，c++编译器会自动地做类型转化工作，转化成功，继续执行，有可能产生不可识别的错误。
**/
#include<iostream>
using namesapce std;
int add(int x, int y) { return x + y; }
int add(int x, int y, int z) { return x + y + z; }
int main()
{
int a = 3, b = 4, c = 5;
cout << a << "+" << b << "=" << add(a, b) << endl;
cout << a << "+" << b << "+" << c << "=" << add(a, b, c) << endl;
return 0;
}
结果如下：
3+4=7
3+4+5=12
8. 作用域标识符 ::
~~~~~~~ 通常情况下，如果有两个同名变量，一个是全局的，一个是局部的，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。
#include <iostream>
using namespace std;
int aver = 10; //定义全局变量 aver
int main()
{
int aver; //定义局部变量 aver
aver = 25;
cout << "aver is " << aver << endl; //输出局部变量 aver 的值
return 0;
}
输出结果：
aver is 25
此时，在main()函数的输出语句中，使用的变量 aver 是在 main() 函数内定义的局部变量，因此输出的是局部变量 aver 的值。如果希望在局部变量的作用域内使用同名的全局变量，可以在该变量前加上 “::” ，此时 ::aver 代表全局变量 aver。
#include <iostream>
using namespace std;
int aver; //定义全局变量 aver
int main()
{
int aver; //定义局部变量 aver
aver = 25; //给局部变量 aver 赋值
::aver = 10; //给全局变量 aver 赋值
cout << "local aver is " << aver << endl; //输出局部变量 aver 的值
cout << "global aver is " << ::aver << endl; //输出全局变量 aver 的值
return 0;
}
输出结果：
local aver is 25
global aver is 10
9. new 和 delete
~~~~~~
C语言中使用函数 malloc 和 free 等进行动态内存管理，C++则提供运算符 new 和 delete 来做同样的工作。基本形式：
~~~~~~
指针变量名 = new 类型
~~~~~~
delete 指针变量名
#include<iostream>
using namespace std;
int main()
{
int *p; //声明一个整形指针变量p;
p = new int; //动态分配一个存放int数据类型的内存空间，并将首地址赋给p;
*p = 10;
cout << *p;
delete p; //释放指针变量p指向的内存空间
return 0;
}
说明：
- new 可以自动计算索要分配的大小，而不必使用 sizeof() 来计算。
- new 能够自动返回正确的指针类型，而不必对返回的指针类型进行强制类型转化。
- 用 new 分配的空间，使用结束后只能用 delete 显示地释放，否则变为死空间。
- new 分配空间时，如果没有足够的内存满足分配，将会返回空指针。
- new 可为数组动态分配内存空间：指针变量名 = new 类型名[下标表达式]。
int *pi = new int[10];
int *pi = new int[1][2][3];
- 释放动态分配的数组存储区时，可用 delete 运算符：delete [ ]指正变量名。
delete []pi; //在指针变量前加一个[],表示对数组空间进行操作
- new 可为简单变量分配内存空间的同时，进行初始化。
10. 引用
1. 引用的概念
~~~~~~ 在c++中，变量的 “引用”就是对变量的别用，因此引用又称为别名。格式如下：类型 &引用名 = 已定义的变量名
int i = 5;
int &j = i; //声明j是一个整形变量i的引用，用整形变量i对它进行初始化，及i变量的别名，具有相同的地址。
说明：
- 引用并不是一种独立的数据格式，它必须与某种类型的变量相联系。在声明引用的时候对它立即进行初始化，不能声明完再赋值。
int i = 10;
int &j; // [X], 没有指定j代表哪个变量
j = i; // [X], 不能声明完成后再赋值
double a;
int &b = a; // [X], 声明b是一个整形变量，而a不是
- 为引用提供的初始值，可以是一个变量或者是另一个引用。
int i = 5;
int &j1 = i; // 声明j1是整形变量i的引用
int &j2 = j1; // 声明j2是整形引用j1的引用
// 这样定义后， 变量i有两个别名j1和j2
2. 引用作为函数参数
- 将变量名作为函数的参数，这种传值是单向的，即“传值调用”，在执行期间形参值发生的变化并不会传回给实参（形参和实参不是占用同一个存储单元）。
- 指针变量作为函数的参数，实参传给形参的是实参变量的地址，即“传址调用”，传值是双向的（同一个存储单元）。
- 引用作为函数的参数，把变量的引用作为函数性形参，即传送变量的别名，传递是双向的。
#include<iostream>
using namespace std;
void swap(int &m, int &n)
{
int temp;
temp = m;
m = n;
n = 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;
}
输出结果：
a=5 b=10
a=10 b=5
3. 使用引用返回函数值
~~~~~~ 使用引用可以返回函数的值，采用这种方法可以将函数调用放在赋值运算符的左边。
4. 对引用的进一步说明
- 不允许建立 void 类型的引用。
void &r = 10; [X]
- 不能建立引用的数组。
int a[4] = "abcd"
int &ra[4] = a; [X]
- 不能建立引用的引用，不能建立指向引用的指针。
int n = 3;
int &&r = n; [X]
int &*p = n; [X]
- 可以将引用的地址赋给一个指针。
int a = 50;
int &b = a;
int *p = &b;
- 可以用 const 对引用加以限制，不允许改变引用的值。
int a = 5;
const int &b = a;
扫一扫
4805
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
