C++常用知识点总结

C++常用知识点总结

1、现在很多教材可能看到的头文件是：

#include <iostream>

然后用现在较新的软件则会提示：无法打开源文件”iostream.h”。
这是因为现在新的软件都是采用标准 C 格式，而 iostream.h 是 VC6.0 使用的风格，也就是标准 C 格式还未出台之前的风格。
出现上述提示只需要进行如下修改:

#include <iostream>
using namespace std;

2、在C++中main函数前面为什么加上int,即int main?
main函数的返回值是返回给主调进程，使主调进程得知被调用程序的运行结果。

标准规范中规定main函数的返回值为int，一般约定返回0值时代表程序运行无错误，其它值均为错误号，但该约定并非强制。

如果程序的运行结果不需要返回给主调进程，或程序开发人员确认该状态并不重要，比如所有出错信息均在程序中有明确提示的情况下，可以不写main函数的返回值。在一些检查不是很严格的编译器中，比如VC, VS等，void类型的main是允许的。不过在一些检查严格的编译器下，比如g++, 则要求main函数的返回值必须为int型。

所以在编程时，区分程序运行结果并以int型返回，是一个良好的编程习惯。

3、变量的自动转换规则
- 若参与运算量的类型不同，则先转换成同一类型，然后进行运算。
- 转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。
- 所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
- char型和short型参与运算时，必须先转换成int型。
- 在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度
- 强制类型转换是通过类型转换运算来实现的。其一般形式为：（类型说明符）（表达式）其功能是把表达式的运算结果强制转换成类型说明符所表示的类型

4、C++时间&日期表示方法
C++ 标准库没有提供所谓的日期类型。C++ 继承了 C 语言用于日期和时间操作的结构和函数。为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用 头文件。
有四个与时间相关的类型：clock_t、time_t、size_t 和 tm。类型 clock_t、size_t 和 time_t 能够把系统时间和日期表示为某种整数。
结构类型 tm 把日期和时间以 C 结构的形式保存，tm 结构的定义如下：

struct tm {
int tm_sec;   // 秒，正常范围从 0 到 59，但允许至 61
int tm_min;   // 分，范围从 0 到 59
int tm_hour;  // 小时，范围从 0 到 23
int tm_mday;  // 一月中的第几天，范围从 1 到 31
int tm_mon;   // 月，范围从 0 到 11
int tm_year;  // 自 1900 年起的年数
int tm_wday;  // 一周中的第几天，范围从 0 到 6，从星期日算起
int tm_yday;  // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起
int tm_isdst; // 夏令时
}

下面以实例介绍如何获取当前系统的时间和日期，包括本地时间和协调世界时

#include <iostream>
#include <ctime>

using namespace std;

int main( )
{
// 基于当前系统的当前日期/时间
   time_t now = time(0);

// 把 now 转换为字符串形式
char* dt = ctime(&now);

cout << "本地日期和时间：" << dt << endl;

// 把 now 转换为 tm 结构
   tm *gmtm = gmtime(&now);
   dt = asctime(gmtm);
cout << "UTC 日期和时间："<< dt << endl;
}

5、C++基本输入输出

• <iostream> 该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。
• <iomanip>该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I/O 有用的服务。
• <fstream> 该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。

6、C++类访问修饰符

• public:公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值
• private:私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。默认情况下，类的所有成员都是私有的
• protected:保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。
  特别需要注意的是，在编程中，要注重共有变量和私有变量的有效结合，尤其是私有变量（privated），何止防范猪队友，更是防范六个月后的自己。

7、类的成员函数
类的成员函数的原型要写在类体中，原型说明了函数的参数表和返回值类型。而函数的定义一般在类外面，也可以直接在类内部定义。
前者与普通函数不同的是，实现成员函数时要指明类的名称，具体形式为：

返回值类型 类名 ：：函数成员名（参数表）{函数体}；

例如：

class Line
{
   public:
double length;
void setLength( double len );
double getLength( void );
};

// 成员函数定义
double Line::getLength(void)
{
return length ;
}

void Line::setLength( double len )
{
length = len;
}

更大体的表示为：

class A
　　{
    　　public:
        　　void B();
    　　private:
        　　int C();
    　　protected:
        　　bool D(int i);
　　};
　　那么，B(),C(),D(int)都是A的成员函数

8、如何理解C++中的继承概念？
面向对象程序设计中最重要的一个概念是继承，简单来说就是根据一个类定义另一个类，使得创建和维护一个应用程序更为容易。

• 假设现在需要创建一个类，那么只需要指定新建类继承了一个已有类的成员即可。已有类我们称为基类，新建类称为派生类。
• 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。
实例：

// 基类
class Shape 
{
public:
void setWidth(int w)
      {
         width = w;
      }
void setHeight(int h)
      {
         height = h;
      }
protected:
int width;
int height;
};

// 派生类
class Rectangle: public Shape
{
public:
int getArea()
      { 
return (width * height); 
      }
};
int main(void)
{
   Rectangle Rect;

   Rect.setWidth(5);
   Rect.setHeight(7);

// 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;

return 0;
}

• 派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。我们可以根据访问权限总结出不同的访问类型
• 多继承即一个子类可以有多个父类，它继承了多个父类的特性。C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

8、C++文件读写
要实现C++的文件读写操作，需要用到标准库fstream，要在 C++ 中进行文件处理，必须在 C++ 源代码文件中包含头文件 <iostream>和 fstream。
- 打开文件，格式为
void open(const char *filename, ios::openmode mode);
在这里，open() 成员函数的第一参数指定要打开的文件的名称和位置，第二个参数定义文件被打开的模式。
ios::app 追加模式。所有写入都追加到文件末尾。
ios::ate 文件打开后定位到文件末尾。
ios::in 打开文件用于读取。
ios::out 打开文件用于写入。
ios::trunc 如果该文件已经存在，其内容将在打开文件之前被截断，即把文件长度设为 0。
具体操作为：

fstream  afile;
afile.open("file.dat", ios::out | ios::in );

• 关闭文件，void close();
• 读取和写入实例

#include <fstream>
#include <iostream>
using namespace std;

int main ()
{

char data[100];

// 以写模式打开文件
   ofstream outfile;
   outfile.open("afile.dat");

cout << "Writing to the file" << endl;
cout << "Enter your name: "; 
cin.getline(data, 100);

// 向文件写入用户输入的数据
   outfile << data << endl;

cout << "Enter your age: "; 
cin >> data;
cin.ignore();

// 再次向文件写入用户输入的数据
   outfile << data << endl;

// 关闭打开的文件
   outfile.close();

// 以读模式打开文件
   ifstream infile; 
   infile.open("afile.dat"); 

cout << "Reading from the file" << endl; 
   infile >> data; 

// 在屏幕上写入数据
cout << data << endl;

// 再次从文件读取数据，并显示它
   infile >> data; 
cout << data << endl; 

// 关闭打开的文件
   infile.close();

return 0;
}

• 位置指针，

// 定位到 fileObject 的第 n 个字节（假设是 ios::beg）
fileObject.seekg( n );

// 把文件的读指针从 fileObject 当前位置向后移 n 个字节
fileObject.seekg( n, ios::cur );

// 把文件的读指针从 fileObject 末尾往回移 n 个字节
fileObject.seekg( n, ios::end );

// 定位到 fileObject 的末尾
fileObject.seekg( 0, ios::end );

9、C++动态内存
C++内存分为两部分，分别是：

• 栈：在函数内部声明的所有变量都将占用栈内存。
• 堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。
  很多时候，您无法提前预知需要多少内存来存储某个定义变量中的特定信息，所需内存的大小需要在运行时才能确定。在 C++ 中，您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存，这会返回所分配的空间地址。这种运算符即 new 运算符。
  如果您不需要动态分配内存，可以使用 delete 运算符，删除之前由 new 运算符分配的内存。
  实例：

#include <iostream>
using namespace std;

int main ()
{
double* pvalue  = NULL; // 初始化为 null 的指针
   pvalue  = new double;   // 为变量请求内存

   *pvalue = 29494.99;     // 在分配的地址存储值
cout << "Value of pvalue : " << *pvalue << endl;

delete pvalue;         // 释放内存

return 0;
}

数组的动态内存分配：

一维数组
// 动态分配,数组长度为 m
int *array=new int [m]；

//释放内存
delete [] array;

二维数组
int **array
// 假定数组第一维长度为 m， 第二维长度为 n
// 动态分配空间
array = new int *[m];
for( int i=0; i<m; i++ )
{
array[i] = new int [n]  ;
}
//释放
for( int i=0; i<m; i++ )
{
delete [] arrar[i];
}
delete [] array;

10、C++命名空间的概念
假设这样一种情况，当一个班上有两个名叫 Zara 的学生时，为了明确区分它们，我们在使用名字之外，不得不使用一些额外的信息，比如他们的家庭住址，或者他们父母的名字等等。

同样的情况也出现在 C++ 应用程序中。例如，您可能会写一个名为 xyz() 的函数，在另一个可用的库中也存在一个相同的函数 xyz()。这样，编译器就无法判断您所使用的是哪一个 xyz() 函数。

因此，引入了命名空间这个概念，专门用于解决上面的问题，它可作为附加信息来区分不同库中相同名称的函数、类、变量等。使用了命名空间即定义了上下文。本质上，命名空间就是定义了一个范围。

• 命名空间的定义使用关键字namespace,后跟命名空间的名称，如下所示：

 namespace namespace_name{
//代码声明
 }

为了调用带有命名空间的函数或变量，需要在前面加上命名空间的名称，如下所示：

name::code;  // code 可以是变量或函数

实例：

#include <iostream>
using namespace std;

// 第一个命名空间
namespace first_space{
void func(){
cout << "Inside first_space" << endl;
   }
}
// 第二个命名空间
namespace second_space{
void func(){
cout << "Inside second_space" << endl;
   }
}
int main ()
{

// 调用第一个命名空间中的函数
   first_space::func();

// 调用第二个命名空间中的函数
   second_space::func(); 

return 0;
}

• using指令，您可以使用 using namespace 指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。
  实例：

#include <iostream>
using namespace std;

// 第一个命名空间
namespace first_space{
void func(){
cout << "Inside first_space" << endl;
   }
}
// 第二个命名空间
namespace second_space{
void func(){
cout << "Inside second_space" << endl;
   }
}
using namespace first_space;
int main ()
{

// 调用第一个命名空间中的函数
   func();

return 0;
}

11、C++多线程和进程

• 基于进程的多任务处理是程序的并发执行。

• 基于线程的多任务处理是同一程序的片段的并发执行。

• 创建进程，下面程序可以用来创建一个POSIX线程

#include <pthread.h>
pthread_create (thread, attr, start_routine, arg) 

thread 指向线程标识符指针。
attr 一个不透明的属性对象，可以被用来设置线程属性。您可以指定线程属性对象，也可以使用默认值 NULL。
start_routine 线程运行函数起始地址，一旦线程被创建就会执行。
arg 运行函数的参数。它必须通过把引用作为指针强制转换为 void 类型进行传递。如果没有传递参数，则使用 NULL.

• 以下简单的实例代码使用 pthread_create() 函数创建了 5 个线程，每个线程输出”Hello Runoob！”:

#include <iostream>
// 必须的头文件
#include <pthread.h>

using namespace std;

#define NUM_THREADS 5

// 线程的运行函数
void* say_hello(void* args)
{
cout << "Hello Runoob！" << endl;
return 0;
}

int main()
{
// 定义线程的 id 变量，多个变量使用数组
    pthread_t tids[NUM_THREADS];
for(int i = 0; i < NUM_THREADS; ++i)
    {
//参数依次是：创建的线程id，线程参数，调用的函数，传入的函数参数
int ret = pthread_create(&tids[i], NULL, say_hello, NULL);
if (ret != 0)
        {
cout << "pthread_create error: error_code=" << ret << endl;
        }
    }
//等各个线程退出后，进程才结束，否则进程强制结束了，线程可能还没反应过来；
    pthread_exit(NULL);
}