c++基础语法

头/源文件例子

// node_process.h
#ifndef SRC_NODE_PROCESS_H_
#define SRC_NODE_PROCESS_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "v8.h"

namespace node{
	v8::MaybeLocal<v8::Object> CreateEnvVarProxy(v8::Local<v8::Context> context, v8::Isolate* isolate);
}

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif  // SRC_NODE_PROCESS_H_


// 其他 .h
namespace node {

	class NodePlatform;
	
	template <class T>
	class TaskQueue { 
		public:
  			TaskQueue();
  		private:
 			Mutex lock_;
	}

	struct DelayedTask {
		uv_timer_t timer;
	}
}

// .cpp
#include "node_process.h"
#include <cmath>
using namespace std;

namespace node {
	using v8::Maybe;
	using v8::MaybeLocal;

	MaybeLocal<Value> ProcessEmit(Environment* env, const char* event,  Local<Value> message) {
	// 代码
	}
}

语法

1. 注释

// 行内注释

/* 注释块 */

2. 输入与输出

OI Wiki 要求的码风不同的代码风格
std 是 C++ 标准库所使用的 命名空间。使用命名空间是为了避免重名。

#include <iostream>

int main() {
  int x, y;                          // 声明变量
  
  // cin 与 cout。
  std::cin >> x >> y;                // 读入 x 和 y
  std::cout << y << std::endl << x;  // 输出 y，换行，再输出 x
	
  // scanf 与 printf （其实是 C 语言提供的函数，大多数情况下，它们的速度比 cin 和 cout 更快，并且能够方便地控制输入输出格式。）
  scanf("%d%d", &x, &y);   // 读入 x 和 y
  printf("%d\n%d", y, x);  // 输出 y，换行，再输出 x
  
  return 0;                          // 结束主函数
}

3. #define 命令

#define 是一种预处理命令，用于定义宏，本质上是文本替换。

#include <iostream>
#define n 233
// n 不是变量，而是编译器会将代码中所有 n 文本替换为 233，但是作为标识符一部分的
// n 的就不会被替换，如 fn 不会被替换成 f233，同样，字符串内的也不会被替换

#define sum(x, y) ((x) + (y))

int main() {
  std::cout << n;  // 输出 233

  std::cout << sum(1, 2) << ' ' << 2 * sum(3, 5) << std::endl;  // 输出 3 16
  
  return 0;
}

使用 #define 是有风险的（由于 #define 作用域是整个程序，因此可能导致文本被意外地替换，需要使用 #undef 及时取消定义），因此应谨慎使用。较为推荐的做法是：使用 const 限定符声明常量，使用函数代替宏。

4. 命名空间

告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念。

using namespace std;

5. 预处理器指令

预处理器在编译之前即读取程序，只执行所有以#开头的行。可以将预处理器看作是一个为编译器 “设置”源代码的程序。
#include 指令使预处理器在程序中包含另一个文件的内容。

#include <iostream>
#include "node_process.h"

6. 作用域符双冒号（::）

（1）表示“域操作符”。例：

声明了一个类A，类A里声明了一个成员函数void f()，
但没有在类的声明里给出f的定义，那么在类外定义f时，
就要写成void A::f()，表示这个f()函数是类A的成员函数。

（2）直接用在全局函数前，表示是全局函数。 例：

在VC里，你可以在调用API 函数里，在API函数名前加 ::

（3）表示引用成员函数及变量，作用域成员运算符。例：

System::Math::Sqrt() 
// 相当于
System.Math.Sqrt()

7. 冒号（:）

（1）表示机构内位域的定义（即该变量占几个bit空间）

typedef struct _XXX{
	unsigned char a:4;
	unsigned char c;
} ; XXX

（2）构造函数后面的冒号起分割作用，是类给成员变量赋值的方法，初始化列表，更适用于成员变量的常量const型。

struct _XXX{
	_XXX() : y(0xc0) {}
};

（3） public:和private:后面的冒号，表示后面定义的所有成员都是公有或私有的，直到下一个"public:”或"private:”出现为止。"private:"为默认处理。

（4）类名冒号后面的是用来定义类的继承。

class 派生类名 : 继承方式 基类名 {
	派生类的成员
};

继承方式：public、private和protected，默认处理是public。

8. 模板

C++中带有空尖括号的模板<>是什么意思？

函数模板是通用的函数描述，也就是说，它们使用泛型来定义函数，其中的泛型可用具体的类型(如int或double)替换。通过将类型作为参数传递给模板，可使编译器生成该类型的函数。由于模板允许以泛型(而不是具体类型)的方式编写程序，因此有时也被称为通用编程。

创建模板，关键字template和typename是必需的，除非可以使用关键字class代替typename。

template <typename T>
void swap(T &a, T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;      
}

隐式实例化：最初，编译器只能通过隐式实例化，来使用模板生成函数定义，这也是我们最常用的方法；如可以像下面这样使用上面定义的函数模板：

short a, b;
swap(a, b); // T 为 short 类型
int c, d;
swap(c, d); // T 为 int 类型

显式实例化： 现在C++还允许显式实例化(explicit instrantiation)。这意味着可以直接命令编译器创建特定的实例，如swap()。其语法是，声明所需的种类——用<>符号指示类型，并在声明前加上关键字template:

template void swap<int>(int, int); // explicit instrantiation

显式具体化： 与显式实例化不同的是，显式具体化使用下面两个等价的声明之一：

template <> void swap<int> (int &, int &);     //explicit specialization
template <> void swap (int &, int &);     //explicit specialization