C++基础常识快速掌握--自学笔记（一）

这里是C++自学时自己做的笔记，记住C++特有的特性，通用性的不做记录，主要以代码实例加深对定义的枯燥的理解吗，所以重点注意代码中的注释内容，快速了解基础内容，了解代码；

C++常见特殊：

cout 为输出，类似java中的system.out.printf()

cin为用户输入，类似java中的scanar

<<输出 连接符 ，类似java中的+（其实java位运算符概念中也有，左移<<）

>>输入连接符（其实java位运算符概念中也有，右移<<）

rand()为随机数，且使用前要加：srand()，类似java中的random（）

using std::setw应该为定义空格，后面使用setw（7）表示前面有7个空格

->为成员访问

C++一般的格式形式如下：

#include<iostream> //头文件usingnamespacestd; //单独写头文件，有些编译器会报错，所以加上这个intmain(){ //c++中main函数的写法  cout << "Hello, world!" << endl; //输出的形式cout与其他不同 ，《这个相当于java的+ return0; //返回值，结束main函数}

typedef声明

 

typedef 为一个已有的类型取一个新的名字

实例：

 typedef int feet; //int也可以叫feet了，feet变成关键字了

 feet abc //相当于int abc ，feet原来不是关键字，所以这里变为合法了

枚举类型

所谓"枚举"是指将变量的值一一列举出来；关键字 enum

enum 枚举名{      标识符[=整型常数],      标识符[=整型常数],      ...      标识符[=整型常数]} 枚举变量;

• ——————————————————————————————————————————————————————

• 在函数或一个代码块内部声明的变量，称为局部变量。

• 在函数参数的定义中声明的变量，称为形式参数。

• 在所有函数外部声明的变量，称为全局变量。

C++ 中的变量声明、定义--

extern 关键字：变量声明只在编译时有它的意义；

extern a；//只是声明编码a存在

变量定义：就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储 

int a=0；//定义并声明变量a

常数实例（声明、定义、初始化的区别）：

// 变量声明externinta,b;externintc;externfloatf;// 变量定义  inta,b;  intc;  floatf;  // 实际初始化  a = 10;  b = 20;  c = a + b;

函数实例：

// 函数声明intfunc(); intmain(){  // 函数调用  inti = func();} // 函数定义intfunc(){  return0;}

数值转换：两个不一样类型的一起，取最小值（与java相反）

实例：

int a=1;double b=2.5;a=b;输出：a=2 ； //取int类型，最大数。与java相反

强制转换：把一个类型转换为另一个类型；

实例：

int a=1;double b=2.5;cout《"a+b="《a+（int）b ；//把b从double类型强制转换为int类型

整数常量

1.前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

2.后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

实例:

212// 合法的215u// 合法的0xFeeL// 合法的078// 非法的：8 不是八进制的数字032UU// 非法的：不能重复后缀85// 十进制0213// 八进制0x4b// 十六进制 30// 整数30u// 无符号整数 30l// 长整数 30ul// 无符号长整数,顺序不分先后

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。

1.您可以使用小数形式或者指数形式来表示浮点常量

2.当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。

3.当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。

4.带符号的指数是用 e 或 E 引入的。

实例：

3.14159// 合法的 314159E-5L// 合法的 510E// 非法的：不完整的指数210f// 非法的：没有小数或指数.e55// 非法的：缺少整数或分数

#define 预处理器

#define identifier value //类似typedef 就是把identifier变为value值或内容，有时看起来像赋值

例如：

#define LENGTH 10  //定义LENGTH 为10，相当于LENGTH=10#define WIDTH  5 //定义WIDTH为10，相当于WIDTH=10#define NEWLINE '\n' //NEWLINE 为\n,相当于他NEWLINE变为换行符了intarea;  area = LENGTH * WIDTH;//相当与10*5得出的值赋予areacout << area;  cout << NEWLINE;

输出：

50

const 关键字

const type variable = value;//和#define类似，就是多了前缀

实例：

const int LENGTH = 10; //和#define类似，就是多了前缀intconst int WIDTH = 5; //同理const char NEWLINE = '\n';//同理intarea;  area = LENGTH * WIDTH;  cout << area;  cout << NEWLINE;

输出：

50

#undef 关键字

1.取消#define的定义；

2.对const不受影响；

实例：

void f1(){  #define N 12  const int n = 12;  #undef N //取消宏定义后，即使在f1函数中，N也无效了  #define N 21//取消后可以重新定义}

#define和const使用方法上的区别

实例

void f1 (){    #define N 12    const int n 12;}void f2 (){    cout<<N <<endl; //正确，N已经定义过，不受定义域限制    cout<<n <<endl; //错误，n定义域只在f1函数中}

extern和const使用方法上的区别

实例：

const int A=10;       //正确。const int A;          //错误，没有赋初始值。extern const int A;   //正确，使用extern的外部变量。

C++ 中的类型限定符

限定符含义constconst 类型的对象在程序执行期间不能被修改改变。volatile修饰符 volatile 告诉编译器，变量的值可能以程序未明确指定的方式被改变。restrict由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。

auto 存储类

auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

根据初始化表达式自动推断被声明的变量的类型，如：

auto f=3.14;      //doubleauto s("hello");  //const char*auto z = new auto(9); // int*auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

register 存储类

register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

registerintmiles;

static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

#include <iostream> // 函数声明 void func(void); /* 全局变量 */static int count = 10; //全局变量有木有static都不影响最后输出结果int main(){ while(count--) { func(); } return 0;}// 函数定义void func( void ){// 局部静态变量static int i = 5; // 此时没有static，i的值将会一直保存不变i++; std::cout << "变量 i 为 " << i ; //局部变量时，若i的值没有static，则i将一直输出6std::cout << " , 变量 count 为 " << count << std::endl;//全局变量没有static的值一直不变}

输出：变量 i 为 6 , 变量 count 为 9变量 i 为 7 , 变量 count 为 8变量 i 为 8 , 变量 count 为 7变量 i 为 9 , 变量 count 为 6变量 i 为 10 , 变量 count 为 5变量 i 为 11 , 变量 count 为 4变量 i 为 12 , 变量 count 为 3变量 i 为 13 , 变量 count 为 2变量 i 为 14 , 变量 count 为 1变量 i 为 15 , 变量 count 为 0

C++ 函数

定义函数和调用函数
函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分：
返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
函数主体：函数主体包含一组定义函数执行任务的语句。
创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。
当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。
调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值
实例：

#include <iostream>using namespace std; // 函数声明int max(int num1, int num2); int main (){   // 局部变量声明   int a = 100;   int b = 200;   int ret;    // 调用函数来获取最大值   ret = max(a, b);    cout << "Max value is : " << ret << endl;    return 0;} // 函数返回两个数中较大的那个数int max(int num1, int num2) {   // 局部变量声明   int result;    if (num1 > num2)      result = num1;   else      result = num2;    return result; }

函数参数
如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。
形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。
当调用函数时，有两种向函数传递参数的方式：
调用类型描述
传值调用该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用该方法把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
引用调用该方法把参数的引用复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
默认情况下，C++ 使用传值调用来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的参数。之前提到的实例，调用 max() 函数时，使用了相同的方法。

Lambda 函数与表达式
C++11 提供了对匿名函数的支持,称为 Lambda 函数(也叫 Lambda 表达式)。
Lambda 表达式本质上与函数声明非常类似。Lambda 表达式具体形式如下:
[](int x, int y){ return x < y ; }

如果没有返回值可以表示为：
[]{ ++global_x; } 

在一个更为复杂的例子中，返回类型可以被明确的指定如下：
[](int x, int y) -> int { int z = x + y; return z + x; }

在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。 与JavaScript闭包不同，C++变量传递有传值和传引用的区别。可以通过前面的[]来指定：
[]      // 沒有定义任何变量。使用未定义变量会引发错误。
[x, &y] // x以传值方式传入（默认），y以引用方式传入。
[&]     // 任何被使用到的外部变量都隐式地以引用方式加以引用。
[=]     // 任何被使用到的外部变量都隐式地以传值方式加以引用。
[&, x]  // x显式地以传值方式加以引用。其余变量以引用方式加以引用。
[=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。

另外有一点需要注意。对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[]的形式，如果要使用 this 指针，必须显式传入：
[this]() { this->someFunc(); }();

定义一个可以输出字符串的lambda表达式，表达式一般都是从方括号[]开始，然后结束于花括号{}，花括号里面就像定义函数那样，包含了lamdba表达式体：
// 定义简单的lambda表达式
auto basicLambda = [] { cout << "Hello, world!" << endl; };
// 调用
basicLambda();
// 输出：Hello, world!

如果需要参数，那么就要像函数那样，放在圆括号里面，如果有返回值，返回类型要放在->后面，即拖尾返回类型，当然你也可以忽略返回类型，lambda会帮你自动推断出返回类型：

// 指明返回类型auto add = [](int a, int b) -> int { return a + b; };// 自动推断返回类型auto multiply = [](int a, int b) { return a * b; };int sum = add(2, 5);   // 输出：7int product = multiply(2, 5);  // 输出：10

C++ 随机数
关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。
下面是一个关于生成随机数的简单实例。实例中使用了 time() 函数来获取系统时间的秒数，通过调用 rand() 函数来生成随机数：

#include <iostream>#include <ctime>#include <cstdlib> using namespace std; int main (){   int i,j;    // 设置种子   srand( (unsigned)time( NULL ) );// time() 函数来获取系统时间的秒数    // 生成实际的随机数   j= rand();//先调用srand()函数，在使用随机数。   cout <<"随机数： " << j << endl;       return 0;}

输出：
随机数： 1748144778
随机数： 630873888
随机数： 2134540646
随机数： 219404170
随机数： 902129458
随机数： 920445370
随机数： 1319072661
随机数： 257938873
随机数： 1256201101
随机数： 580322989

C++ 数组
内容和java数组差不多，不果断阐述
实例：

#include <iostream>using namespace std; #include <iomanip>using std::setw;//应该定义空格 int main (){   int n[ 10 ]; // n 是一个包含 10 个整数的数组    // 初始化数组元素             for ( int i = 0; i < 10; i++ )   {      n[ i ] = i + 100; // 设置元素 i 为 i + 100   }   cout << "Element" << setw( 13 ) << "Value" << endl;//setw( 13 )应该是指有13和空格    // 输出数组中每个元素的值                        for ( int j = 0; j < 10; j++ )   {      cout << setw( 7 )<< j << setw( 13 ) << n[ j ] << endl; //setw( 7 )和setw( 13 )应该是指有7和13个空格   }    return 0;}

输出：
数组后面都有空格

Element        Value      0          100      1          101      2          102      3          103      4          104      5          105      6          106      7          107      8          108      9          109

C++ 中数组详解
在 C++ 中，数组是非常重要的，我们需要了解更多有关数组的细节。下面列出了 C++ 程序员必须清楚的一些与数组相关的重要概念：
概念描述
多维数组C++ 支持多维数组。多维数组最简单的形式是二维数组。
指向数组的指针您可以通过指定不带索引的数组名称来生成一个指向数组中第一个元素的指针。
传递数组给函数您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
从函数返回数组C++ 允许从函数返回数组。

C++ 字符串
C 风格的字符串起源于 C 语言，并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。
函数定义，需要记忆，快速使用，有些规律，如：都是str开头，后面跟着英文是此属性方法
序号函数 & 目的1strcpy(s1, s2);
复制字符串 s2 到字符串 s1。2strcat(s1, s2);
连接字符串 s2 到字符串 s1 的末尾。3strlen(s1);
返回字符串 s1 的长度。4strcmp(s1, s2);
如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。5strchr(s1, ch);
返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。6strstr(s1, s2);
返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。下面的实例使用了上述的一些函数：

#include <iostream>#include <cstring> using namespace std; int main (){   char str1[11] = "Hello"; //char改成string方法也是一样   char str2[11] = "World"; //char改成string方法也是一样   char str3[11]; //char改成string方法也是一样   int  len ;    // 复制 str1 到 str3   strcpy( str3, str1);   cout << "strcpy( str3, str1) : " << str3 << endl;    // 连接 str1 和 str2   strcat( str1, str2);   cout << "strcat( str1, str2): " << str1 << endl;    // 连接后，str1 的总长度   len = strlen(str1);   cout << "strlen(str1) : " << len << endl;    return 0;}

输出：
strcpy( str3, str1) : Hello
strcat( str1, str2): HelloWorld
strlen(str1) : 10

C++ 指针
在C和C++类中，指针很重要，
每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：
type *var-name;

在这里，type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：
int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;    /* 一个字符型的指针 */

所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

C++ 中使用指针
使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。
这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。下面的实例涉及到了这些操作：

#include <iostream> using namespace std; int main (){   int  var = 20;   // 实际变量的声明   int  *ip;        // 指针变量的声明    ip = &var;       // 在指针变量中存储 var 的地址，var所存放的地址赋值给ip    cout << "Value of var variable: ";   cout << var << endl; //var的值不变    // 输出在指针变量中存储的地址   cout << "Address stored in ip variable: ";   cout << ip << endl; //ip应该是var的地址    // 访问指针中地址的值   cout << "Value of *ip variable: ";   cout << *ip << endl; //指针到该地址取值    return 0;}

输出：

注意：var、ip、*ip的值，这里&var的作用，明白这几个就了解了

Value of var variable: 20Address stored in ip variable: 0xbfc601acValue of *ip variable: 20

C++ 指针详解

在 C++ 中，有很多指针相关的概念，这些概念都很简单，但是都很重要。下面列出了 C++ 程序员必须清楚的一些与指针相关的重要概念：

概念描述C++ Null 指针C++ 支持空指针。NULL 指针是一个定义在标准库中的值为零的常量。C++ 指针的算术运算可以对指针进行四种算术运算：++、--、+、-C++ 指针 vs 数组指针和数组之间有着密切的关系。C++ 指针数组可以定义用来存储指针的数组。C++ 指向指针的指针C++ 允许指向指针的指针。C++ 传递指针给函数通过引用或地址传递参数，使传递的参数在调用函数中被改变。C++ 从函数返回指针C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。

C++ 引用

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：

• 不存在空引用。引用必须连接到一块合法的内存。
• 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
• 引用必须在创建时被初始化。指针可以在任何时间被初始化。

C++ 中创建引用

试想变量名称是变量附属在内存位置中的标签，您可以把引用当成是变量附属在内存位置中的第二个标签。因此，您可以通过原始变量名称或引用来访问变量的内容。例如：

int i = 17;

我们可以为 i 声明引用变量，如下所示：

int&    r = i;

在这些声明中，& 读作引用。

实例：

下面的实例使用了 int 和 double 引用：

#include <iostream> using namespace std; int main (){   // 声明简单的变量   int    i;   double d;    // 声明引用变量   int&    r = i;//第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，   double& s = d;//第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。      i = 5;   cout << "Value of i : " << i << endl;   cout << "Value of i reference : " << r  << endl; //r的值是引用i的值    d = 11.7;   cout << "Value of d : " << d << endl;   cout << "Value of d reference : " << s  << endl; //d的值是引用s的值      return 0;}

输出：

Value of i : 5Value of i reference : 5Value of d : 11.7Value of d reference : 11.7

引用通常用于函数参数列表和函数返回值。下面列出了 C++ 程序员必须清楚的两个与 C++ 引用相关的重要概念：

概念描述把引用作为参数C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。把引用作为返回值可以从 C++ 函数中返回引用，就像返回其他数据类型一样。

C++ 日期 & 时间

C++ 标准库没有提供所谓的日期类型。C++ 继承了 C 语言用于日期和时间操作的结构和函数。为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用 <ctime> 头文件。

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; // 夏令时}

当前日期和时间

下面的实例获取当前系统的日期和时间，包括本地时间和协调世界时（UTC）。

#include <iostream>#include <ctime> //时间和日期要引用此头文件 using namespace std; int main( ){  /*获取电脑的本地系统时间*/   // 基于当前系统的当前日期/时间   time_t now = time(0);      // 把 now 转换为字符串形式   char* dt = ctime(&now);    cout << "本地日期和时间：" << dt << endl;   /*获取UTC 日期和时间*/ // 把 now 转换为 tm 结构 tm *gmtm = gmtime(&now); dt = asctime(gmtm); cout << "UTC 日期和时间："<< dt << endl;}

输出：
本地日期和时间：Sat Jan  8 20:07:41 2011 


UTC 日期和时间：Sun Jan  9 03:07:41 2011
使用结构 tm 格式化时间
tm 结构在 C/C++ 中处理日期和时间相关的操作时，显得尤为重要。tm 结构以 C 结构的形式保存日期和时间。大多数与时间相关的函数都使用了 tm 结构。下面的实例使用了 tm 结构和各种与日期和时间相关的函数。
在练习使用结构之前，需要对 C 结构有基本的了解，并懂得如何使用箭头 -> 运算符来访问结构成员。

#include <iostream>#include <ctime> using namespace std; int main( ){   // 基于当前系统的当前日期/时间   time_t now = time(0);    cout << "1970 到目前经过秒数:" << now << endl;    tm *ltm = localtime(&now);    // 输出 tm 结构的各个组成部分   cout << "年: "<< 1900 + ltm->tm_year << endl;   cout << "月: "<< 1 + ltm->tm_mon<< endl;   cout << "日: "<<  ltm->tm_mday << endl;   cout << "时间: "<< ltm->tm_hour << ":";   cout << ltm->tm_min << ":";   cout << ltm->tm_sec << endl;}

输出：
1970 到目前时间:1503564157
年: 2017
月: 8
日: 24
时间: 16:42:37

C++ 基本的输入输出
C++ 的 I/O 发生在流中，流是字节序列。
如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。
如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。
I/O 库头文件
下列的头文件在 C++ 编程中很重要。
头文件           函数和描述
<iostream>该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。
<iomanip>          该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I/O 有用的服务。
<fstream>          该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。

标准输出流（cout）
这就是讲输出的，用cout为输出相当于java的system.out.printf（）；<< 为连接符相当于java中的+，endl 为换行符相当于java中的/n。
<< 在一个语句中可以多次使用，如下
cout << "Value of str is : " << str << endl;
标准错误流（cerr）
类似cout输出流
预定义的对象 cerr 是 ostream 类的一个实例。cerr 对象附属到标准错误设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。
cerr 也是与流插入运算符 << 结合使用的，如下所示：

#include <iostream> using namespace std; int main( ){   char str[] = "Unable to read....";    cerr << "Error message : " << str << endl;}

输出：
Error message : Unable to read....

标准日志流（clog）
预定义的对象 clog 是 ostream 类的一个实例。clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲在，直到缓冲填满或者缓冲区刷新时才会输出。
clog 也是与流插入运算符 << 结合使用的，如下所示：

#include <iostream> using namespace std; int main( ){   char str[] = "Unable to read....";    cerr << "Error message : " << str << endl;}

输出：
Error message : Unable to read....

通过这些小实例，我们无法区分 cout、cerr 和 clog 的差异，但在编写和执行大型程序时，它们之间的差异就变得非常明显。
所以良好的编程实践告诉我们，使用 cerr 流来显示错误消息，而其他的日志消息则使用 clog 流来输出。普通的输出显示用cout流来输出

标准输入流（cin）
这是讲输入的，用cin为输入相当于java中的scanner由用户输入；>>为提取运算符
>>可多次使用，如下所示
cin >> name >> age;

#include <iostream> using namespace std; int main( ){   char name[50];    cout << "请输入您的名称： ";   cin >> name;//由用户输入   cout << "您的名称是： " << name << endl; }

输出：
有用户输入：cplusplus
请输入您的名称： cplusplus
您的名称是： cplusplus

C++ 数据结构
结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：
Title ：标题
Author ：作者
Subject ：类目
Book ID ：书的 ID


typedef 关键是一种更简单的定义结构的方式，您可以为创建的类型取一个"别名"。例如：

typedef struct{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;}Books;

定义结构
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

struct type_name {//type_name是结构体类型的名称member_type1 member_name1;//member_type1 member_name1 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。member_type2 member_name2;member_type3 member_name3;..} object_names;//在结构定义的末尾，最后一个分号之前，您可以指定一个或多个结构变量，这是可选的。

在来看下案例

struct Books //声明一个结构体类型 Books，{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;} book;//变量为 book：

访问结构成员
为了访问结构的成员，我们使用成员访问运算符（.）。如：Book1.title，成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。

下面的实例演示了结构的用法：

#include <iostream>#include <cstring> using namespace std; // 声明一个结构体类型 Books struct Books{   char  title[50];//50个字符的数组   char  author[50];   char  subject[100];   int   book_id;//int整型数组}; int main( ){   Books Book1;        // 定义结构体类型 Books 的变量 Book1   Books Book2;        // 定义结构体类型 Books 的变量 Book2    // Book1 详述   strcpy( Book1.title, "C++ 教程"); //Book1调用title的数组空间（字符型），把“C++教程”字符放入数组中，Book1去调用（用“.”）。strcpy是复制函数   strcpy( Book1.author, "Runoob");    strcpy( Book1.subject, "编程语言");   Book1.book_id = 12345; //book_id为int整型数组    // Book2 详述   strcpy( Book2.title, "CSS 教程");   strcpy( Book2.author, "Runoob");   strcpy( Book2.subject, "前端技术");   Book2.book_id = 12346;    // 输出 Book1 信息   cout << "第一本书标题 : " << Book1.title <<endl;   cout << "第一本书作者 : " << Book1.author <<endl;   cout << "第一本书类目 : " << Book1.subject <<endl;   cout << "第一本书 ID : " << Book1.book_id <<endl;    // 输出 Book2 信息   cout << "第二本书标题 : " << Book2.title <<endl;   cout << "第二本书作者 : " << Book2.author <<endl;   cout << "第二本书类目 : " << Book2.subject <<endl;   cout << "第二本书 ID : " << Book2.book_id <<endl;    return 0;}

输出：
第一本书标题 : C++ 教程
第一本书作者 : Runoob
第一本书类目 : 编程语言
第一本书 ID : 12345
第二本书标题 : CSS 教程
第二本书作者 : Runoob
第二本书类目 : 前端技术
第二本书 ID : 12346

结构作为函数参数
您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。您可以使用上面实例中的方式来访问结构变量：
多出：printBook( Book1 );和printBook( Book2 );

#include <iostream>#include <cstring> using namespace std;void printBook( struct Books book ); // 声明一个结构体类型 Books struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;}; int main( ){   Books Book1;        // 定义结构体类型 Books 的变量 Book1   Books Book2;        // 定义结构体类型 Books 的变量 Book2     // Book1 详述，Book1的值   strcpy( Book1.title, "C++ 教程");   strcpy( Book1.author, "Runoob");    strcpy( Book1.subject, "编程语言");   Book1.book_id = 12345;    // Book2 详述，Book2的值   strcpy( Book2.title, "CSS 教程");   strcpy( Book2.author, "Runoob");   strcpy( Book2.subject, "前端技术");   Book2.book_id = 12346;    // 输出 Book1 信息   printBook( Book1 );//调用函数，把Book1值转进去    // 输出 Book2 信息   printBook( Book2 );//同理    return 0;}void printBook( struct Books book )//函数方法{   cout << "书标题 : " << book.title <<endl;   cout << "书作者 : " << book.author <<endl;   cout << "书类目 : " << book.subject <<endl;   cout << "书 ID : " << book.book_id <<endl;}

输出：
书标题 : C++ 教程
书作者 : Runoob
书类目 : 编程语言
书 ID : 12345
书标题 : CSS 教程
书作者 : Runoob
书类目 : 前端技术
书 ID : 12346

指向结构的指针
这个难理解，要仔细看
您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：
struct Books *struct_pointer;
现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：
struct_pointer = &Book1;
为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：
struct_pointer->title;
让我们使用结构指针来重写上面的实例，这将有助于您理解结构指针的概念：

#include <iostream>#include <cstring> using namespace std;void printBook( struct Books *book ); struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;}; int main( ){   Books Book1;        // 定义结构体类型 Books 的变量 Book1   Books Book2;        // 定义结构体类型 Books 的变量 Book2     // Book1 详述   strcpy( Book1.title, "C++ 教程");   strcpy( Book1.author, "Runoob");    strcpy( Book1.subject, "编程语言");   Book1.book_id = 12345;    // Book2 详述   strcpy( Book2.title, "CSS 教程");   strcpy( Book2.author, "Runoob");   strcpy( Book2.subject, "前端技术");   Book2.book_id = 12346;    // 通过传 Book1 的地址来输出 Book1 信息   printBook( &Book1 );    // 通过传 Book2 的地址来输出 Book2 信息   printBook( &Book2 );    return 0;}// 该函数以结构指针作为参数void printBook( struct Books *book ){   cout << "书标题  : " << book->title <<endl;   cout << "书作者 : " << book->author <<endl;   cout << "书类目 : " << book->subject <<endl;   cout << "书 ID : " << book->book_id <<endl;}

输出：
书标题  : C++ 教程
书作者 : Runoob
书类目 : 编程语言
书 ID : 12345
书标题  : CSS 教程
书作者 : Runoob
书类目 : 前端技术

书 ID : 12346

请参考：http://www.runoob.com/cplusplus/cpp-tutorial.html