天天看點
傳回

C++基礎常識快速掌握--自學筆記（一）C++ 引用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得出的值賦予area
cout << area;  
cout << NEWLINE;

輸出：

50

const 關鍵字 

const type variable = value;//和#define類似，就是多了字首

執行個體：

const int LENGTH = 10; //和#define類似，就是多了字首int
const 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++ 中的類型限定符

限定符 含義
const const 類型的對象在程式執行期間不能被修改改變。
volatile 修飾符 volatile 告訴編譯器，變量的值可能以程式未明确指定的方式被改變。
restrict 由 restrict 修飾的指針是唯一一種通路它所指向的對象的方式。隻有 C99 增加了新的類型限定符 restrict。

auto 存儲類

auto  關鍵字用于兩種情況：聲明變量時根據初始化表達式自動推斷該變量的類型、聲明函數時函數傳回值的占位符。

根據初始化表達式自動推斷被聲明的變量的類型，如：

auto f=3.14;      //double
auto 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将一直輸出6
std::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);   // 輸出：7
int 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開頭，後面跟着英文是此屬性方法

序号 函數 & 目的
1

strcpy(s1, s2);

複制字元串 s2 到字元串 s1。
2

strcat(s1, s2);

連接配接字元串 s2 到字元串 s1 的末尾。
3

strlen(s1);

傳回字元串 s1 的長度。
4

strcmp(s1, s2);

如果 s1 和 s2 是相同的，則傳回 0；如果 s1<s2 則傳回值小于 0；如果 s1>s2 則傳回值大于 0。
5

strchr(s1, ch);

傳回一個指針，指向字元串 s1 中字元 ch 的第一次出現的位置。
6

strstr(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;    

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: 20
Address stored in ip variable: 0xbfc601ac
Value 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 : 5
Value of i reference : 5
Value of d : 11.7
Value 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

---------------------------------完，不明白的給我留言·······················

C/C++/C#
上一篇: c++之常識
下一篇: C、C++、Java的基礎常識介紹

繼續閱讀