c++基础知识

结构体

C++ 语言中 struct 与 C 语言中 struct 的区别
1.在 C++ 语言中，可直接使用结构体名来声明变量；在 C 语言中，不能直接使用结构体名来声明变量，需前缀 struct。
2.C++ 语言的 struct 中既可以定义成员变量又可以定义成员函数；C 语言的 struct 中只能定义成员变量，不能定义成员函数。
 

符号“::”在C++中叫做作用域限定符，我们通过“命名空间名称::命名空间成员”便可以访问到命名空间中相应的成员。

 静态存储区分配

静态分配方式下的内存在程序编译的时候就已经分配好了且存在于程序的整个运行过程。例如 static 变量，其生命周期随程序的结束而结束，而非像一般变量随函数或作用域的结束而结束。
除了 static 变量，还有一种全局对象 static object ，也可以存放在静态存储区。

 栈内存分配

栈内存分配方式下的内存是存在于某作用域的一块空间。例如调用某个函数时，函数内局部变量的存储单元可以在栈上创建，函数执行结束时，这些内存单元会自动被释放。
函数内局部变量的生命周期：起于变量声明，至于函数执行结束。

 堆内存分配

堆内存分配，也称 “动态内存分配”，通常使用 new 和 delete 关键字进行管理。堆内存空间可由用户手动分配和释放，所以其生存周期由用户指定，比较灵活。但频繁的分配、释放大小不同的堆空间会产生内存碎片。

 管理堆内存

C语言中一般使用malloc()函数来分配内存空间，free()函数来释放内存空间。但在C++语言中我们使用new关键字来分配内存空间，delete 关键字来释放内存空间。后者在性能等方面优于前者。
在学习使用 new 和 delete 关键字之前我们先初步了解一下指针的概念及其一般形式。
指针是一个变量，其值是另一个变量的地址。指针变量声明的一般格式为：

type *pointerVar-name
其中type为指针的数据类型，*是定义指针的关键符，pointerVar-name指定指针变量名。
注意：使用 new 获取的内存空间必须使用 delete 进行释放。

#include<iostream>
using namespace std;
int main()
{
    int *p;
    p = new int;
    *p = 6;
    cout << *p << endl;
    delete p ;
    return 0;
}

continue：结束本次循环，所在循环体并未结束。
break：结束整个循环体，所在循环体已结束。
goto 语句允许把控制无条件转移到同一函数内的标记语句。但在任何的编程语言中，都不建议使用 goto 语句，因为它使得程序的控制流难以跟踪。

#include<iostream>
using namespace std;
int main()
{
    int i =3;
    if(i == 3)
    {
        goto acc;
    }
    else
    {
        cout << i <<endl;
    }
    acc:cout << "acc" <<endl;
    return 0;
}

函数的定义

C++ 中的函数分为 C++ 标准库函数和自定义函数。使用标准库函数需要包含特定的头文件，比如使用 vector 功能时，需包含头文件 #include。而自定义函数是用户自定义命名和声明的一组语句，其基本结构为：

type name(parameter list){
    code
}
其中 type 为函数的返回值类型；name 为函数的名称，也是调用函数所使用的标识符；parameter list 为传递给函数的参数列表；code 为函数的主体，存放函数需要执行的语句。例如我们定义一个 add 函数：

int add(int a,int b){
    return a + b;
}
函数重载
指的是函数同名的情况，这种情况下我们往往通过函数参数的个数形式来区分。

#include<iostream>
using namespace std;

int add(int a,int b){ //定义整型函数 add。
    int c;
    c = a - b;
    return c;
}

double add(double a,double b){ //定义双精度型函数 add。
    double c;
    c = a + b;
    return c;
}

int main()
{//函数重载。
    cout<<"a + b = "<<add(3,4)<<endl;//调用整型函数 add。
    cout<<"a + b = "<<add(3.111,4.222)<<endl;//调用双精度型函数 add。
}

面向对象程序设计的基本特点包括：抽象、封装、继承、多态。

类一般由类名、数据成员、函数成员三部分组成，定义类的基本形式为：

class 类的名称
{
    public：
        外部接口
    protected：
        保护性成员
    private：
        私有成员
}

其中 public、protected、private 表示访问控制属性，用于控制类成员的访问权限。特别的，没有分配控制属性的默认为 private 私有成员。

#include<iostream>
using namespace std;

class area //定义 area 类。
{
    public: //定义公有成员，外部可以访问。
        double width;
        double length;
};

int main()
{
    area area1; //定义对象 area1。
    double AREA; //定义双精度型变量 AREA。
    area1.width=3; //外部访问公有成员，设置宽为 3。
    area1.length=3.1; //外部访问公有成员，设置长为 3.1。
    AREA=area1.width*area1.length; //计算面积。
    cout << AREA <<endl; //输出面积
    return 0;
}
 

#include<iostream>
using namespace std;

class area //定义 area 类。
{
    protected://定义受保护的成员。
        double width;
};

class squarearea:area //定义 squarearea 子类。
{
    public: //定义公有成员。
        void setsquarewidth(double wid); //定义成员函数。
        double getsquarewidth(void);
};

//定义子类的成员函数。
void squarearea::setsquarewidth(double wid)
{
    width=wid; //通过 squarearea 子类访问 area 类中受保护的成员 width。
}
double squarearea::getsquarewidth(void)
{
    return width;
}

//程序的主函数 。
int main()
{
    squarearea square; //定义对象。
    square.setsquarewidth(3.1); //设置宽度为 3.1。
    cout <<"width:"<<square.getsquarewidth()<<endl; //输出设置的宽度。
    return 0;
}
 

#include<iostream>
using namespace std;

class area
{
    public: //定义公有成员
        double length;
        void setwidth(double wid);
        double getwidth(void);
    private://定义私有成员
        double width;
};

//定义公有成员函数
void area::setwidth(double wid)
{
    width=wid;
}
double area::getwidth(void)
{
    return width;
}

//主函数
int main()
{
    area len1; //定义对象
    area wid1;
    len1.length=3.1; //访问 area 类公有成员。
    cout<<"length:"<<len1.length<<endl;
    wid1.setwidth(3.2); //使用公有成员函数设置宽度。
    cout <<"width:"<<wid1.getwidth()<<endl;
    return 0;
}
 

类的成员函数
成员函数描述了类的行为。成员函数在类中只用说明其函数的返回类型、名字和参数表，而函数的具体实现在类外说明，其基本形式为：

class 类名
{
    函数的返回类型 函数名(参数列表)
}

返回值类型 类名::函数名(参数列表) //特别的，在类外说明函数的具体实现时，需要使用类名限制成员函数，其形式为：类名::函数名(参数列表)。
{
    函数体
}
 

指针是 C++ 从 C 中继承的重要数据类型，它提供了一种较为直接的地址操作手段，使用指针可灵活实现动态内存的分配。
指针变量的声明
指针是一种数据类型，具有指针类型的变量称为 指针变量，它用于存放内存地址。在使用指针之前，需对指针进行声明，其一般形式为：

type *pointer_name;

其中 type 表示所指对象的数据类型，即说明所指内存单元存放的数据类型；* 表示声明一个指针类型的变量；pointer_name 表示指针名。
值得注意的是，指针实际存放的是内存地址，不同类型的指针变量用于指向数据类型不同的变量或常量。

C++ 中提供了两个与地址相关的运算符：* 和 & 。其中 * 称为 指针运算符，用于获取指针所指变量的值，例如 *p 表示指针 p 所指变量的值；& 称为 取地址运算符，用于获取一个对象的地址，例如有变量 i，则 &i 表示 i 的存储地址。
指针的赋值与使用
定义指针后我们仅得到了一个用于存储地址的指针变量，若要确定指针变量存放的内存地址，可以通过给指针赋值实现。其基本形式为：
1.在定义指针时为指针赋值：
type *pointer_name=初始地址;

2.在定义指针后为指针赋值：

type *pointer_name;
pointer_name=初始地址;

其中 初始地址 为某个对象的内存地址，一般使用 &对象名 获取。
引用
引用是指对已存在的变量别名，我们可以使用引用名来指向对象。

引用与指针主要有三个区别：

可以通过 指针名=0 描述一个空指针，但不存在空引用。
指针可在任何时间进行初始化操作，而引用只能在定义时进行初始化操作。
指针变量指向内存的一个存储单元；而引用只不过是原变量的一个别名而已。
声明引用变量的基本格式为：
type &引用名=被指对象名；
& 在这里是标识作用，而非取地址运算符。

 

Int、float、double、char等类型的输出格式：

(1) int：%d
(2) float: %f, 默认保留6位小数
(3) double: %lf， 默认保留6位小数
(4) char: %c, 回车也是一个字符，用’\n’表示

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    int a = 3;
    float b = 3.12345678;
    double c = 3.12345678;
    char d = 'y';

    printf("%d\n", a);
    printf("%f\n", b);
    printf("%lf\n", c);
    printf("%c\n", d);

    return 0;
}
float, double等输出保留若干位小数时用：%.4f, %.3lf

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    float b = 3.12345678;
    double c = 3.12345678;

    printf("%.4f\n", b);
    printf("%.3lf\n", c);

    return 0;
}

最小数字宽度

a. %8.3f, 表示这个浮点数的最小宽度为8，保留3位小数，当宽度不足时在前面补空格。

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    int a = 3;
    float b = 3.12345678;
    double c = 3.12345678;

    printf("%5d\n", a);
    printf("%8.4f\n", b);
    printf("%7.3lf\n", c);

    return 0;
}
 

b. %-8.3f，表示最小宽度为8，保留3位小数，当宽度不足时在后面补上空格

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    int a = 3;
    float b = 3.12345678;
    double c = 3.12345678;

    printf("%-5d!\n", a);
    printf("%-8.4f!\n", b);
    printf("%-7.3lf!\n", c);

    return 0;
}
c. %08.3f, 表示最小宽度为8，保留3位小数，当宽度不足时在前面补上0

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    int a = 3;
    float b = 3.12345678;
    double c = 3.12345678;

    printf("%05d\n", a);
    printf("%08.4f\n", b);
    printf("%07.3lf\n", c);

    return 0;
}