C++ 設計原則
Bjarne Stroustrup 博士在 20 世紀 80 年代在貝爾實驗室工作期間發明並實現了 C++。
一開始的想法可以追溯到 1979 年，起初這種語言被稱作「C with Classes」，作為 C 語言的增強版出現。
C++ 在 C 的基礎上增加功能，並且儘量與 C 的相容。
C++ 比起其它語言有巨大優勢的地方，就是可以直接使用 C 的函式。
C++ 編譯器自由軟體的主要實作為 GNU Compiler Collection (GCC) 與
Clang。
C++ 是一個通用的語言，抽象資料型別為 C++ 的核心概念，
含有一些系統程式領域的特性，並且期望能夠達到下列的目標：
- is a better C
- supports data abstraction
- supports object-oriented programming
- supports generic programming
在《C++語言的設計和演化》(1994)中，
Bjarne Stroustrup 描述了他在設計C++時，所使用的一些原則。
- C++ 設計成靜態類型、和 C同樣高效率且可移植的多用途程式設計語言。
- C++ 設計成直接的和廣泛的支援多種程式設計風格。
- C++ 設計成給程式設計者更多的選擇，即使可能導致程式設計者選擇錯誤。
- C++ 設計成盡可能與 C 相容，籍此提供一個從 C 到 C++ 的平滑過渡。
- C++ 避免平臺限定或沒有普遍用途的特性。
- C++ 不使用會帶來額外開銷的特性。
- C++ 設計成無需複雜的程式設計環境。
但是，C++ 標準並沒有規範 Object Model 的實作方式，同時 C++ 也缺乏 ABI 的標準，
因此在 Windows Platform 上各家編譯器所產出的 DLL 很難互通，這是 C++ 在 binary level 上的缺點。
下面是一個 C 的 Hello World 程式：
#include <stdio.h>
int main() {
/* my first program in C */
printf("Hello, World! \n");
return 0;
}
In a C program, the semicolon is a statement terminator.
That is, each individual statement must be ended with a semicolon.
It indicates the end of one logical entity.
C++標準表頭檔沒有副檔名，因為副檔名的命名規則隨各編譯器而有所不同。
下面是 C++ 版的 Hello World：
#include <iostream>
int main() {
std::cout << "Hello! World!\n";
return 0;
}
下面是一個範例，使用者在命令列輸入一個字串，然後程式計算字串 MD5 的值並且輸出：
//
// g++ test.cpp -std=c++17 -lcrypto
//
#include <cstring>
#include <string>
#include <iostream>
#include <openssl/md5.h>
std::string MD5(const std::string &src)
{
MD5_CTX ctx;
std::string md5_string;
unsigned char md[16] = {0};
char tmp[3] = {0};
MD5_Init(&ctx);
MD5_Update(&ctx, src.c_str(), src.size());
MD5_Final(md, &ctx);
for (int i = 0; i < 16; ++i)
{
memset(tmp, 0x00, sizeof(tmp));
snprintf(tmp, sizeof(tmp), "%02X", md[i]);
md5_string += tmp;
}
return md5_string;
}
int main(int argc, char *argv[])
{
if (argc == 1)
{
std::cout << "Please give a string." << std::endl;
}
else
{
std::string mystring = argv[1];
std::cout << "String: " << mystring << std::endl;
std::cout << "Result: " << MD5(mystring) << std::endl;
}
return 0;
}
下面是一個範例，使用者在命令列輸入一個字串，然後程式計算字串 SHA256 的值並且輸出：
//
// g++ test.cpp -std=c++17 -lcrypto
//
#include <cstring>
#include <string>
#include <iostream>
#include <openssl/sha.h>
std::string SHA256(const std::string &src)
{
SHA256_CTX ctx;
std::string sha256_string;
unsigned char md[32] = {0};
char tmp[3] = {0};
SHA256_Init(&ctx);
SHA256_Update(&ctx, src.c_str(), src.size());
SHA256_Final(md, &ctx);
for (int i = 0; i < 32; ++i)
{
memset(tmp, 0x00, sizeof(tmp));
snprintf(tmp, sizeof(tmp), "%02X", md[i]);
sha256_string += tmp;
}
return sha256_string;
}
int main(int argc, char *argv[])
{
if (argc == 1)
{
std::cout << "Please give a string." << std::endl;
}
else
{
std::string mystring = argv[1];
std::cout << "String: " << mystring << std::endl;
std::cout << "Result: " << SHA256(mystring) << std::endl;
}
return 0;
}
Date types
C++ 中基本的資料型態主要區分為「整數」（Integer）、「浮點數」（Float）、「字元」（Character），而這幾種還可以細分：
- 整數：用 來表示整數值，可以區分為 short、int 與 long，可容納的大小各不相同，short的長度為半個 word，int 表示一個 word，
而 long 可能是一個或兩個 word（要看採用的 data model），在 32 位元機器上 int 與 long 的長度通常是相同的，
型態的長度越長，表示可表示的整數值範圍越大。
如果是 64 位元的機器 (64-bit computing)，
大多數的 UNIX 系統在 64 位元採用 LP64 data model，這時候 long 就會是 8 bytes。
而 Windows 64 位元採用 LLP64 這個 data model，這時候 long 的大小仍然還是 4 bytes，也就是差異出現在 long 這個型別上。
- 浮點數：用來表示小數值，可以區分為 float、double 與 long double，float 的長度為一個 word，double 的長度為二個 word，
long double 長度為 3 或 4 個word。
- 字元：用來儲存字元，長度為 1 個位元組，其字元編碼主要依 ASCII 表而來，由於字元在記憶體中所佔有的空間較小，
所以它也可以用來儲存較小範圍的整數。
以上的資料型態在記憶體中所佔有的大小依平台系統而有所差異，word 的大小取決於機器，在 32 位元機器上通常一個 word 是 4 個位元組，
如果想要知道這些資料型態在所使用的平台上所佔有的記憶體空間有多少，最好的作法是使用 sizeof() 運算子，取得確實的記憶體大小。
在 C11 標準中，建議包括 stdint.h 程式庫（亦包含在 C++ 的標準函式庫），
使用 int8_t、int16_t、int32_t、
int64_t、uint8_t、uint16_t、uint32_t、
uint64_t 等作為整數型態的宣告，以避免平台相依性的問題。
有時候我們需要表示非十進位的數字（例如八進位或者十六進位）。
在 C 其八進位通常以「0」開頭（注意是數字 0），例如 0640；而十六進位通常以「0x」或「0X」開頭，例如 0xEF 或 0XEF；
而二進位通常以「0b」開頭，例如 0b1。
要注意的是，如果是需要精確求值的場合，那麼需要考慮使用 big number library 來實作，而不是使用浮點數。
有些程式語言（例如 Tcl、Common Lisp 等）直接支援大整數運算，無需顯式地使用 API。
使用浮點數有兩個最根本的問題：輸入與儲存的值不一定精確與計算的結果會有誤差。
另外，電腦的浮點數常用二進位或十六進位運算與儲存，所以在程式中的十進位數需要轉換為二進位或十六進位，
但是一個簡單的十進位數卻可能轉換成無限位的二進位或十六進位數，而儲存的位置是有限的，
算出來的結果就不夠精確，結果也可能受到四捨五入誤差的影響，如果再用來計算其它值，誤差就會愈滾愈大。
There are two kinds of expressions in C −
- lvalue − Expressions that refer to a memory location are called "lvalue" expressions.
An lvalue may appear as either the left-hand or right-hand side of an assignment.
- rvalue − The term rvalue refers to a data value that is stored at some address in memory.
An rvalue is an expression that cannot have a value assigned to it which means an rvalue
may appear on the right-hand side but not on the left-hand side of an assignment.
Constants refer to fixed values that the program may not alter during its execution. These fixed values are also called literals.
Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal.
There are two simple ways in C to define constants −
- Using #define preprocessor.
- Using const keyword.
Given below is the form to use #define preprocessor to define a constant −
#define identifier value
The following example explains it in detail −
#include <stdio.h>
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main() {
int area;
area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);
return 0;
}
You can use const prefix to declare constants with a specific type as follows −
const type variable = value;
The following example explains it in detail −
#include <stdio.h>
int main() {
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;
area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);
return 0;
}
Macros in C and C++ are tokens that are processed by the preprocessor before compilation.
Each instance of a macro token is replaced with its defined value or expression before the file is compiled.
Macros are commonly used in C-style programming to define compile-time constant values.
However, macros are error-prone and difficult to debug.
In modern C++, you should prefer constexpr variables for compile-time constants:
#define SIZE 10 // C-style
constexpr int size = 10; // modern C++
constexpr 可以說是 C++11 對 const 修飾字的加強。
常數表達式 (constant expression) 代表的是可以在編譯時期經過固定確定運算得到確切值的表達式。
A storage class defines the scope (visibility) and life-time of variables and/or functions within a C Program.
They precede the type that they modify. We have four different storage classes in a C program −
- auto
- register
- static
- extern
The auto storage class is the default storage class for all local variables.
{
int mount;
auto int month;
}
The register storage class is used to define local variables that should be stored in a register instead of RAM.
{
register int miles;
}
The static storage class instructs the compiler to keep a local variable in existence during the life-time of the program instead of creating and destroying it each time it comes into and goes out of scope. Therefore, making local variables static allows them to maintain their values between function calls.
The extern storage class is used to give a reference of a global variable that is visible to ALL the program files.
When you use 'extern', the variable cannot be initialized however,
it points the variable name at a storage location that has been previously defined.
Arrays a kind of data structure that can store a fixed-size sequential collection of elements of the same type.
An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.
You can initialize an array in C either one by one or using a single statement as follows −
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
If you omit the size of the array, an array just big enough to hold the initialization is created. Therefore, if you write −
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
A pointer is a variable whose value is the address of another variable, i.e., direct address of the memory location.
Like any variable or constant, you must declare a pointer before using it to store any variable address.
#include <stdio.h>
int main () {
int var = 20; /* actual variable declaration */
int *ip; /* pointer variable declaration */
ip = &var; /* store address of var in pointer variable*/
printf("Address of var variable: %x\n", &var );
/* address stored in pointer variable */
printf("Address stored in ip variable: %x\n", ip );
/* access the value using the pointer */
printf("Value of *ip variable: %d\n", *ip );
return 0;
}
It is always a good practice to assign a NULL value to a pointer variable in case you do not have an exact address to be assigned.
This is done at the time of variable declaration. A pointer that is assigned NULL is called a null pointer.
Arrays are not pointers! Arrays look like pointers, and pointers can refer to array objects.
For example, people sometimes think that char s[] is identical to char *s. But they aren’t identical.
The array declaration char s[12] requests that space for 12 characters be set aside, to be known by the name s.
The pointer declaration char *p, on the other hand, requests a place that holds a pointer, to be known by the name p.
This pointer can point to almost anywhere: to any char, to any contiguous array of chars, or frankly nowhere.
參考（Reference）是 C++ 新增加的語言特性，為物件的別名（Alias），也就是替代名稱，對參考名稱存取時該有什麼行為，
都參考了來源物件該有的行為，在 C++ 中，「物件」這個名詞，不單只是指類別的實例，而是指記憶體中的一塊資料。
要定義參考，是在型態關鍵字後加上 & 運算子，例如：
int n = 10;
int *p = &n;
int &r = n;
上面的程式中，最後一行定義參考。參考一定要初始化，否則無法通過編譯。
與指標 (pointer) 不同，參考在初始化之後不能參照不同的物件，或設為 null，也因此參考一般而言比指標安全。
C 並沒有為 String 定義一個型別，字串在 C 語言中是一個以 null character '\0' 為結尾的一維陣列。
這讓 C 的字串需要小心的處理。
如果要在 C 進行字串串接，可以使用 asprintf，雖然是 GNU 自行擴充的 function，但是使用上很方便。
#define _GNU_SOURCE
#include <stdio.h>
下面則是使用的例子：
char *s;
asprintf(&s,"hello,%s","-Reader-");
printf("%s\n",s);
if (s) free(s);
C++ 在這一點則有所改變，加入了 std::string 作為字串物件類別。
Arrays allow to define type of variables that can hold several data items of the same kind.
Similarly structure is another user defined data type available in C that allows to combine data items of different kinds.
To define a structure, you must use the struct statement.
The struct statement defines a new data type, with more than one member. The format of the struct statement is as follows −
struct [structure tag] {
member definition;
member definition;
...
member definition;
} [one or more structure variables];
The structure tag is optional and each member definition is a normal variable definition,
such as int i; or float f; or any other valid variable definition. At the end of the structure's definition,
before the final semicolon, you can specify one or more structure variables but it is optional.
Here is the way you would declare the Book structure −
struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
An enum is a special type that represents a group of constants (unchangeable values).
下面是一個 enum 的例子：
enum Level {
LOW,
MEDIUM,
HIGH
};
下面就是宣告變數並且初始化的例子：
enum Level myVar = MEDIUM;
「Scoped and strongly typed enums」是 C++11 時所引進的一個新的功能，主要是要取代舊的列舉型別（enum）。
基本用法是在 enum 後面，再加上 class 或 struct；而要使用定義的值的時候，一定要加上範圍（scope、在這裡就是指 class 的名稱）。
enum class EColor
{
RED,
GREEN,
BLUE
};
EColor eColor = EColor::RED;
另外，在 C++11 開始，不管是 enum 或 enum class，也都可以指定實際要使用的型別。
enum class EColor : char
{
RED,
GREEN,
BLUE
};
A union is a special data type available in C that allows to store different data types in the same memory location.
You can define a union with many members, but only one member can contain a value at any given time.
Unions provide an efficient way of using the same memory location for multiple-purpose.
To define a union, you must use the union statement in the same way as you did while defining a structure.
The union statement defines a new data type with more than one member for your program. The format of the union statement is as follows −
union [union tag] {
member definition;
member definition;
...
member definition;
} [one or more union variables];
The union tag is optional and each member definition is a normal variable definition, such as int i;
or float f; or any other valid variable definition. At the end of the union's definition, before the final semicolon,
you can specify one or more union variables but it is optional.
Here is the way you would define a union type named Data having three members i, f, and str −
union Data {
int i;
float f;
char str[20];
} data;
Now, a variable of Data type can store an integer, a floating-point number, or a string of characters.
It means a single variable, i.e., same memory location, can be used to store multiple types of data.
You can use any built-in or user defined data types inside a union based on your requirement.
The memory occupied by a union will be large enough to hold the largest member of the union.
For example, in the above example, Data type will occupy 20 bytes of memory space
because this is the maximum space which can be occupied by a character string.
The declaration of a bit-field has the following form inside a structure −
struct {
type [member_name] : width ;
};
The variables defined with a predefined width are called bit fields. A bit field can hold more than a single bit; for example,
if you need a variable to store a value from 0 to 7, then you can define a bit field with a width of 3 bits as follows −
struct {
unsigned int age : 3;
} Age;
The C programming language provides a keyword called typedef, which you can use to give a type a new name.
Following is an example to define a term BYTE for one-byte numbers −
typedef unsigned char BYTE;
You can use typedef to give a name to your user defined data types as well.
For example, you can use typedef with structure to define a new data type and then use
that data type to define structure variables directly as follows −
#include <stdio.h>
#include <string.h>
typedef struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
} Book;
int main( ) {
Book book;
strcpy( book.title, "C Programming");
strcpy( book.author, "Nuha Ali");
strcpy( book.subject, "C Programming Tutorial");
book.book_id = 6495407;
printf( "Book title : %s\n", book.title);
printf( "Book author : %s\n", book.author);
printf( "Book subject : %s\n", book.subject);
printf( "Book book_id : %d\n", book.book_id);
return 0;
}
The C Preprocessor is not a part of the compiler, but is a separate step in the compilation process.
In simple terms, a C Preprocessor is just a text substitution tool and it instructs the compiler
to do required pre-processing before the actual compilation. We'll refer to the C Preprocessor as CPP.
All preprocessor commands begin with a hash symbol (#). It must be the first nonblank character,
and for readability, a preprocessor directive should begin in the first column.
ANSI C defines a number of macros.
#include <stdio.h>
int main() {
printf("File :%s\n", __FILE__ );
printf("Date :%s\n", __DATE__ );
printf("Time :%s\n", __TIME__ );
printf("Line :%d\n", __LINE__ );
printf("ANSI :%d\n", __STDC__ );
}
The token-pasting operator (##) within a macro definition combines two arguments.
It permits two separate tokens in the macro definition to be joined into a single token. For example −
#include <stdio.h>
#define tokenpaster(n) printf ("token" #n " = %d", token##n)
int main(void) {
int token34 = 40;
tokenpaster(34);
return 0;
}
A header file is a file with extension .h which contains C function declarations and macro definitions to be shared between several source files.
There are two types of header files: the files that the programmer writes and the files that comes with your compiler.
You request to use a header file in your program by including it with the C preprocessing directive #include,
like you have seen inclusion of stdio.h header file, which comes along with your compiler.
Including a header file is equal to copying the content of the header file but we do not do it
because it will be error-prone and it is not a good idea to copy the content of a header file in the source files,
especially if we have multiple source files in a program.
A simple practice in C or C++ programs is that we keep all the constants, macros,
system wide global variables, and function prototypes in the header files and include that header file wherever it is required.
If a header file happens to be included twice, the compiler will process its contents twice and it will result in an error.
The standard way to prevent this is to enclose the entire real contents of the file in a conditional, like this −
#ifndef HEADER_FILE
#define HEADER_FILE
the entire header file file
#endif
Control flow
C 語言用來判斷條件的 statement 有二個，if 和 switch。
另外還有條件運算子 ? : 這個運算子。
Exp1 ? Exp2 : Exp3;
C 語言迴圈包含了 while, for 與 do ... while 等三種迴圈。
Write a program that displays the digits from 1 to n then back down to 1;
for instance, if n = 5, the program should display 123454321.
You are permitted to use only a single for loop. The range is 0 < n < 10.
首先是使用 switch 來解：
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int n = 0;
if (argc >= 2) {
n = atoi(argv[1]);
} else {
fprintf(stderr, "Please give a number.\n");
return 1;
}
if (n < 1 || n > 9) {
fprintf(stderr, "Out of range.\n");
return 1;
}
switch (n) {
case 1:
printf("1\n");
break;
case 2:
printf("121\n");
break;
case 3:
printf("12321\n");
break;
case 4:
printf("1234321\n");
break;
case 5:
printf("123454321\n");
break;
case 6:
printf("12345654321\n");
break;
case 7:
printf("1234567654321\n");
break;
case 8:
printf("123456787654321\n");
break;
case 9:
printf("12345678987654321\n");
break;
default:
printf("Please input 0 < n < 10\n");
break;
}
return 0;
}
接下來，改為使用 while 的版本：
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int n = 0;
if (argc >= 2) {
n = atoi(argv[1]);
} else {
fprintf(stderr, "Please give a number.\n");
return 1;
}
if (n < 1 || n > 9) {
fprintf(stderr, "Out of range.\n");
return 1;
}
int positive = 1;
int count = 0;
while (1) {
if (positive == 1) {
count++;
printf("%d", count);
if (count == n) {
positive = 0;
continue;
}
} else {
count--;
if (count > 0) {
printf("%d", count);
} else {
break;
}
}
}
printf("\n");
return 0;
}
C++ 的控制結構大致上與 C 相同，在 C++11 增加了以範圍為基礎的 for 陳述式。
#include <iostream>
int main() {
for (int i : {1, 2, 3}) {
std::cout << i << std::endl;
}
return 0;
}
Function
函式 (Function) 的組成主要包括四個部份：返回值、函式名稱、參數列與函式主體。前三者稱為函式宣告或函式原型（Function prototype），
在 C++ 中規定，如果函式是在 main 之後實作，必須在 main 之前進行宣告，否則會出現編譯錯誤。
如果函式不傳回任何值，則宣告為 void，若不傳入任何引數，參數列保持空白即可，雖然也可以使用 void 來加以註明，
要注意的是 void 註明參數列不使用為是 C 的風格，而在 C++ 中，參數列空白就表示這個函式不接受任何引數。
在含入標頭檔時，若標頭檔與含入標頭檔的文件在同一目錄，就使用雙引號 " " 來包括標頭檔名稱，如果是標準或專案專屬的標頭檔，例如 C++ 的標準表頭檔，那麼使用角括號 < > 來括住，編譯器在尋找時就會從設定的目錄尋找。
下面是 C 語言對函式的參數沒有固定數目時的方法。
#include <stdio.h>
#include <stdarg.h>
double average(int num,...) {
va_list valist;
double sum = 0.0;
int i;
/* initialize valist for num number of arguments */
va_start(valist, num);
/* access all the arguments assigned to valist */
for (i = 0; i < num; i++) {
sum += va_arg(valist, int);
}
/* clean memory reserved for valist */
va_end(valist);
return sum/num;
}
int main() {
printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));
printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}
C 語言在 <stdlib.h> 定義了關於記憶體管理的函式，例如 malloc, realloc 與 free。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char name[100];
char *description = NULL;
strcpy(name, "Zara Ali");
/* allocate memory dynamically */
description = (char *) malloc( 200 * sizeof(char) + 1);
if( description == NULL ) {
fprintf(stderr, "Error - unable to allocate required memory\n");
} else {
strcpy( description, "Zara ali a DPS student in class 10th");
}
printf("Name = %s\n", name );
printf("Description: %s\n", description );
/* Free memory */
if(description) free(description);
}
下面是人類猜數字的小遊戲：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
int getA(char *ans, char *guess) {
int len1 = 0;
int len2 = 0;
int count = 0;
len1 = strlen(ans);
len2 = strlen(guess);
if (len1 != len2) {
return 0;
}
for (int i = 0; i < len1; i++) {
if (ans[i] == guess[i]) {
count++;
}
}
return count;
}
int getB(char *ans, char *guess) {
int len1 = 0;
int len2 = 0;
int count = 0;
len1 = strlen(ans);
len2 = strlen(guess);
if (len1 != len2) {
return 0;
}
for (int i = 0; i < len1; i++) {
for (int j = 0; j < len2; j++) {
if (i != j) {
if (ans[i] == guess[j]) {
count++;
}
}
}
}
return count;
}
int main() {
int answer = 1;
char ans[5];
char guess[5];
int avalue = 0;
int bvalue = 0;
srand(time(0));
while (1) {
answer = (int)(rand() % 9999);
sprintf(ans, "%04d", answer);
if (ans[0] != ans[1] && ans[0] != ans[2] && ans[0] != ans[3] &&
ans[1] != ans[2] && ans[1] != ans[3] && ans[2] != ans[3]) {
break;
}
}
while (1) {
printf("Please input your guess: ");
scanf("%s", guess);
avalue = getA(ans, guess);
bvalue = getB(ans, guess);
printf("Result: A = %d, B = %d\n", avalue, bvalue);
if (avalue == 4 && bvalue == 0) {
printf("Game is completed.\n");
break;
}
printf("\n");
}
}
下面是電腦猜數字的小遊戲：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int getA(char *ans, char *guess) {
int len1 = 0;
int len2 = 0;
int count = 0;
len1 = strlen(ans);
len2 = strlen(guess);
if (len1 != len2) {
return 0;
}
for (int i = 0; i < len1; i++) {
if (ans[i] == guess[i]) {
count++;
}
}
return count;
}
int getB(char *ans, char *guess) {
int len1 = 0;
int len2 = 0;
int count = 0;
len1 = strlen(ans);
len2 = strlen(guess);
if (len1 != len2) {
return 0;
}
for (int i = 0; i < len1; i++) {
for (int j = 0; j < len2; j++) {
if (i != j) {
if (ans[i] == guess[j]) {
count++;
}
}
}
}
return count;
}
int main() {
int count = 0;
int index = 0;
char **total;
char **total_new;
char **newtotal;
char ans[5];
int avalue = 0;
int bvalue = 0;
total = (char **)malloc(sizeof(char *) * 5040);
if (!total) {
printf("Malloc failed.\n");
return 0;
}
for (int i = 0; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
for (int k = 0; k <= 9; k++) {
for (int m = 0; m <= 9; m++) {
if (i != j && i != k && i != m && j != k && j != m && k != m) {
char buffer[5] = {0};
sprintf(buffer, "%d%d%d%d", i, j, k, m);
total[count] = (char *)malloc(sizeof(char) * 5);
strcpy(total[count], buffer);
count++;
}
}
}
}
}
while (1) {
if (count == 0) {
printf("Something is wrong.\n");
break;
}
strcpy(ans, total[0]);
printf("My answer is %s.\n", ans);
printf("The a value is: ");
scanf("%d", &avalue);
printf("The b value is: ");
scanf("%d", &bvalue);
if (avalue == 4 && bvalue == 0) {
printf("Game is completed.\n");
break;
}
index = 0;
newtotal = (char **)malloc(sizeof(char *) * count);
for (int i = 0; i < count; i++) {
int aguess = 0;
int bguess = 0;
aguess = getA(total[i], ans);
bguess = getB(total[i], ans);
if (aguess == avalue && bguess == bvalue) {
newtotal[index] = (char *)malloc(sizeof(char) * 5);
strcpy(newtotal[index], total[i]);
index++;
}
}
total_new = (char **)realloc(total, sizeof(char *) * index);
if (!total_new) {
printf("Realloc failed.\n");
break;
}
total = total_new;
for (int i = 0; i < index; i++) {
strcpy(total[i], newtotal[i]);
}
for (int i = 0; i < index; i++) {
if (newtotal[i]) {
free(newtotal[i]);
}
}
if (newtotal) {
free(newtotal);
}
count = index;
printf("\n");
}
for (int i = 0; i < count; i++) {
if (total[i])
free(total[i]);
}
if (total) {
free(total);
}
}
realloc 的行為要特別注意，如果失敗會傳回 NULL，但是原本配置的記憶體並不會釋放！所以需要特別處理。
C++ Class
變數（Variable）提供一個有名稱的記憶體儲存空間，一個變數關係至一個資料型態，一個變數本身的值與一個變數的位址值。
變數資料型態決定了變數所分配到的記憶體大小；變數本身的值是指儲存於記憶體中的某個數值，而您可以透過變數名稱取得這個數值，
這個數值又稱為 rvalue或 read value；而變數的位址值則是指變數所分配到的記憶體之位置，變數本身又稱為lvalue或 location value。
由於 C++ 的演化來自 C，在 C++ 中的術語
物件和 C
語言一樣是意味著
記憶體區域，而不是類別實體。在 class
中，有兩大成員，一是資料（data member），一是行為（member function）。
C++ 使用 new 和 delete 來建立和刪除物件，
string *stringPtr1 = new string;
delete stringPtr1;
下面是另外一個形式：
string *stringPtr1 = new string[100];
delete [] stringPtr1;
C++ 的 new 運算子和 C 的 malloc 函式都是為了要配置記憶體，但是 new 不但配置物件所需的記憶體空間，同時會引發
建構式的執行。
雖然 new 運算子看起來是單一運算，但是包含了二個動作：
- 透過適當的 new 運算子函式實體，配置所需的記憶體（new 運算子配置所需的記憶體實作上幾乎都是以標準的 C malloc() 來完成，正如 delete 運算子是以 C free() 來完成）
- 將所配置的物件設立初值
Brace initialization
It is not always necessary to define a constructor for a class, especially ones that are relatively simple.
Users can initialize objects of a class or struct by using uniform initialization, as shown in the following example:
// no_constructor.cpp
// Compile with: cl /EHsc no_constructor.cpp
#include <time.h>
// No constructor
struct TempData
{
int StationId;
time_t timeSet;
double current;
double maxTemp;
double minTemp;
};
// Has a constructor
struct TempData2
{
TempData2(double minimum, double maximum, double cur, int id, time_t t) :
stationId{id}, timeSet{t}, current{cur}, maxTemp{maximum}, minTemp{minimum} {}
int stationId;
time_t timeSet;
double current;
double maxTemp;
double minTemp;
};
int main()
{
time_t time_to_set;
// Member initialization (in order of declaration):
TempData td{ 45978, time(&time_to_set), 28.9, 37.0, 16.7 };
// Default initialization = {0,0,0,0,0}
TempData td_default{};
// Uninitialized = if used, emits warning C4700 uninitialized local variable
TempData td_noInit;
// Member declaration (in order of ctor parameters)
TempData2 td2{ 16.7, 37.0, 28.9, 45978, time(&time_to_set) };
return 0;
}
Note that when a class or struct has no constructor,
you provide the list elements in the order that the members are declared in the class.
If the class has a constructor, provide the elements in the order of the parameters.
If a type has a default constructor, either implicitly or explicitly declared,
you can use default brace initialization (with empty braces).
For example, the following class may be initialized by using both default and non-default brace initialization:
#include <string>
using namespace std;
class class_a {
public:
class_a() {}
class_a(string str) : m_string{ str } {}
class_a(string str, double dbl) : m_string{ str }, m_double{ dbl } {}
double m_double;
string m_string;
};
int main()
{
class_a c1{};
class_a c1_1;
class_a c2{ "ww" };
class_a c2_1("xx");
// order of parameters is the same as the constructor
class_a c3{ "yy", 4.4 };
class_a c3_1("zz", 5.5);
}
If a class has non-default constructors,
the order in which class members appear in the brace initializer is the order in which the corresponding parameters appear in the constructor,
not the order in which the members are declared (as with class_a in the previous example).
靜態變數與函式
static 成員變數不屬於物件的一部份，而是類別的一部份，所以可以在沒有建立任何物件的情況下就處理 static 成員變數。而且即使
static 成員變數的權限為 private，設定 static 成員變數初值時，不受任何存取權限的束縛。
static 成員函式和 static 成員變數一樣，可以在沒有建立任何物件的情況下就被呼叫執行。
而之所以可以在未建立任何物件的情況下就被呼叫執行，
是因為編譯器不會為它暗自加上一個 this 指標，
也因為缺少 this 指標，static 成員函式無法處理類別之中的 non-static 成員變數。
C++ Object Model
Stroustrup 所設計的 Model：
- Nonstatic data members 被配置在每一個 class object 之內
- static data members 被配置在個別的 class object 之外
- function members 被配置在個別的 class object 之外
- 每一個 class 產生出指向 virtual functions 的指標，放在表格中（virtual table）。
每一個 class object 都被安插一個指標，指向相關的virtual table。
- 為了支援 RTTI，會在 virtual table 的第一個 slot 插入型別資訊
多型的實現方式很複雜，大致上是編譯器或 VM 在資料結構內加入一個資料指標，此指標通常稱爲 vptr，是 Virtual Table
Pointer 的意思。vptr 指向一個 Virtual Table，此 Virtual Table 是一個陣列
(array)，由許多函數指標所組成，每個函數指標各自指向一個函數的地址。不管是 C++ 編譯器、或是 Java VM、或是 .NET
CLR，內部都是以此方式來實現多型。
C++ Object Model 提供了有效率的執行時期支援，再加上與 C 之間的相容性，造成了 C++ 的流行。但是因為 Object
Layout （物件大小、每一個非虛擬的 member）在編譯時間就已經固定下來，在 binary level 上阻礙了使用的彈性。
C++：封裝（Encapsulation）
資訊隱藏的意義在於將物件的實際內容除非有必要，否則最好將實際內容隱藏在介面裡。
C++ 的存取等級分為 public, protected, private 三種，把資料宣告為
private，只能透過特定的介面來操作，這就是物件導向的封裝（encapsulation）特性。
C++：繼承 (Inherit)
繼承：讓使用者藉由在已經有的類別上，加入新成員（資料或者是函式來定義新的類別，而不必重新設計。
C++ 的繼承分為三種情況：
成員函式有一個隱藏參數，名為 this 指標（代表著物件自己），因此可以知道所應喚起的函式。
C++ 多型支援：虛擬函式
對物件導向的程式語言來說，在繼承關係發生的同時，子類別可能會去覆寫父類別的函式。因此在所謂「多型」的機制下，
就無法在編譯時期決定要呼叫的究竟是那個函式，也就是到了執行時期才決定要呼叫的究竟是那一個函式（所引申的意義，就是多型的前提是繼承，
只有繼承才有多型行為的產生）。
物件導向的三個特色：封裝、繼承、多型，其中最重要的多型，C++ 是靠繼承和動態繫結（Dynamic binding）達成，
「虛擬函式」可以實現「執行時期」的多型支援，是一個「動態繫結」，
也就是指必須在執行時期才會得知所要調用的物件或其上的公開介面，以相同的指令卻喚起了不同的函式，也就是「一種介面，多種用途」。
如果 C++ 沒有虛擬函式，如果以一個「基礎類別之指標」指向一個「衍生類別之物件」，
那麼使用此指標就只能夠呼叫基礎類別（而不是衍生類別）所定義的函式。C++ 透過指標或參考來支援多型，以 Virtual function 來達到多型的實現，
Virtual function 在基底類別中使用關鍵字 virtual 宣告，並在衍生類別中重新定義虛擬函式。
多型與動態繫結只有在使用指標或參考時才得以發揮它們的特性。
虛擬函式可以實現執行時期的「多型」，一個含有虛擬函式的類別被稱為「多型的類別」（Polymorphic class），
當一個基底類別型態的指標指向一個含有虛擬函式的衍生類別，您就可以使用這個指標來存取衍生類別中的虛擬函式。
class Window // Base class for C++ virtual function example
{
public:
virtual void Create() // virtual function for C++ virtual function example
{
cout <<"Base class Window"<<endl;
}
};
class CommandButton : public Window
{
public:
void Create()
{
cout<<"Derived class Command Button - Overridden C++ virtual function"<<endl;
}
};
void main()
{
Window *x, *y;
x = new Window();
x->Create();
y = new CommandButton();
y->Create();
}
如果沒有宣告為 virtual 的話，CommandButton 所呼叫的 Create() 仍然為 base class 所定義的
Create()，但是宣告為 virtual function 之後，將會視所使用的指標型別而決定要喚起的函式，因此將可以增加使用上的彈性。
純虛擬函式 (Pure Virtual Function)
C++ 提供「純虛擬函式」（Pure virtualfunction），它的存在只是為了在衍生類別中被重新定義，指明某個函式只是提供一個介面，
要求繼承的子類別必須重新定義該函式。
class Work {
public:
// pure virtual function
virtual void doJob() = 0;
};
一個類別中如果含有純虛擬函式，則該類別為一「抽象類別」（Abstract class），
該類別只能被繼承，而不能用來直接生成實例，如果直接產生實例會發生編譯錯誤。
final specifier and override specifier
C++11 標準提供了對虛擬函式更好的表達方式。
final specifier specifies that a virtual function cannot be overridden in a derived class or that a class cannot be inherited from.
如果設定為 final，就表示這就是最後一個覆寫的 virtual function。
struct Base
{
virtual void foo();
};
struct A : Base
{
void foo() final; // A::foo is overridden and it is the final override
void bar() final; // Error: non-virtual function cannot be overridden or be final
};
struct B final : A // struct B is final
{
void foo() override; // Error: foo cannot be overridden as it's final in A
};
struct C : B // Error: B is final
{
};
override specifier specifies that a virtual function overrides another virtual function.
也就是用來指定是否可以覆寫 virtual function。
struct A
{
virtual void foo();
void bar();
};
struct B : A
{
void foo() const override; // Error: B::foo does not override A::foo
// (signature mismatch)
void foo() override; // OK: B::foo overrides A::foo
void bar() override; // Error: A::bar is not virtual
};
對於 C++ 而言，因為其設計哲學是「任何特性在不使用的時候，絕對不增加程式的負擔」，所以在不使用虛擬特性的時候，就不會增加呼叫時的負擔。與
Java 這些內建使用動態繫結的語言不同，C++ 比較偏向使用靜態繫結，只有在使用 Virtual 關鍵字時才具有動態繫結的能力，因此與其說
C++ 是一個物件導向語言，不如說是支援物件導向的 Template based 語言。
Templates
Templates are parametrized by one or more template parameters, of three kinds:
type template parameters, non-type template parameters, and template template parameters.
C++ 所提供的 template
機制，就是將目標物的資料型別參數化。
下面是一個 template 的例子：
template <class T>
inline const T& max(const T& a, const T& b)
{
return a < b ? b : a;
}
一旦程式以指定引數的方式，確定了型別之後，編譯器便自動針對這個（或這些）型別產生出一份實體。
針對目標物之不同，C++ 支援 function templates 和 class templates 兩大類型，
而後者的 members 又可以是 templates（所謂 member templates），帶來極大的彈性與組合空間。
「由編譯器產生出一份實體」的動作，我們稱之為具現化（instantiation）。由於 Template
具現化的行為是在編譯時期完成，所以愈複雜的 templates，就會需要愈多的編譯時間。然而 template
卻不會影響到執行時間，因此對於程式的執行效率仍然得以保障。
C++ 泛型編程的中心思考是 Template，運算子多載也為 C++ 泛型編程帶來了幫助，
讓我們得以用看起來行為像函式的 Function Object （函式物件, or Functor）寫出更有彈性的程式。
Standard Template Library 是 C++ 泛型編程開花結果之後所帶來的成品，讓我們得以享用這些高編程品質的函式庫。
Templates 是 C++ 支援泛型的重要關鍵。
template<typename To, typename From> To convert(From f);
void g(double d)
{
int i = convert<int>(d); // calls convert<int,double>(double)
char c = convert<char>(d); // calls convert<char,double>(double)
int(*ptr)(float) = convert; // instantiates convert<int, float>(float)
}
關鍵字：typename
C++ 引進了 typename 關鍵字，用來指定 template 內的標識符號為一種型別。
C++ 的規則是，除非用 typename 修飾，template 內的標識符號都會被視為一個實值 (value) 而不是型別。
Parameter pack (since C++11)
A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates).
A function parameter pack is a function parameter that accepts zero or more function arguments.
A template with at least one parameter pack is called a variadic template.
template<class ... Types> struct Tuple {};
Tuple<> t0; // Types contains no arguments
Tuple<int> t1; // Types contains one argument: int
Tuple<int, float> t2; // Types contains two arguments: int and float
Tuple<0> error; // error: 0 is not a type
A variadic function template can be called with any number of function arguments
(the template arguments are deduced through template argument deduction):
template<class ... Types> void f(Types ... args);
f(); // OK: args contains no arguments
f(1); // OK: args contains one argument: int
f(2, 1.0); // OK: args contains two arguments: int and double
A pattern followed by an ellipsis, in which the name of at least one parameter pack appears at least once,
is expanded into zero or more comma-separated instantiations of the pattern,
where the name of the parameter pack is replaced by each of the elements from the pack, in order.
template<class ...Us> void f(Us... pargs) {}
template<class ...Ts> void g(Ts... args) {
f(&args...); // “&args...” is a pack expansion
// “&args” is its pattern
}
g(1, 0.2, "a"); // Ts... args expand to int E1, double E2, const char* E3
// &args... expands to &E1, &E2, &E3
// Us... pargs expand to int* E1, double* E2, const char** E3
Type casting
Type casting is a way to convert a variable from one data type to another data type.
For example, if you want to store a 'long' value into a simple integer then you can type cast 'long' to 'int'.
You can convert the values from one type to another explicitly using the cast operator as follows −
(type_name) expression
Consider the following example where the cast operator causes the division of one integer variable
by another to be performed as a floating-point operation −
#include <stdio.h>
main() {
int sum = 17, count = 5;
double mean;
mean = (double) sum / count;
printf("Value of mean : %f\n", mean );
}
Type conversions can be implicit which is performed by the compiler automatically,
or it can be specified explicitly through the use of the cast operator.
It is considered good programming practice to use the cast operator whenever type conversions are necessary.
因為更重視型別安全的關係，除了上面 C 語言風格的型別轉換，
C++ 加入了 static_cast、dynamic_cast、const_cast、reinterpret_cast 四種 cast。
static_cast 執行於編譯時期，功能與 C-Style cast 相似，但更安全，可以避免不合理的型別轉換。
float f = 3.5;
int n1 = static_cast<int>(f);
為了支援執行時期的型態轉換動作，C++ 提供了dynamic_cast 用來將一個基底類別的指標轉型至衍生類別指標，
稱之為「安全向下轉型」（Safe downcasting），它在執行時期進行型態轉換動作，首先會確定轉換目標與來源是否屬同一個類別階層，
接著才真正進行轉換的動作，檢驗動作在執行時期完成，如果是一個指標，則轉換成功時傳回位址，失敗的話會傳回 0，
如果是參考的話，轉換失敗會丟出 bad_cast例外。
#include <iostream>
#include <typeinfo>
using namespace std;
class Base {
public:
virtual void foo() = 0;
};
class Derived1 : public Base {
public:
void foo() {
cout << "Derived1" << endl;
}
void showOne() {
cout << "Yes! It's Derived1." << endl;
}
};
class Derived2 : public Base {
public:
void foo() {
cout << "Derived2" << endl;
}
void showTwo() {
cout << "Yes! It's Derived2." << endl;
}
};
void showWho(Base &base) {
try {
Derived1 derived1 = dynamic_cast<Derived1&>(base);
derived1.showOne();
}
catch(bad_cast) {
cout << "bad_cast 轉型失敗" << endl;
}
}
int main() {
Derived1 derived1;
Derived2 derived2;
showWho(derived1);
showWho(derived2);
return 0;
}
const_cast 的用途是移除 const 的屬性。除非真的有需要，否則不應該使用。
const int a = 10;
const int *ptr = &a;
int *cc = const_cast<int *>(ptr);
*cc = 99;
reinterpret_cast 用途是強制轉換型別，不論資料大小是否相同。
int number = 10;
// Store the address of number in numberPointer
int* numberPointer = &number;
// Reinterpreting the pointer as a char pointer
char* charPointer
= reinterpret_cast<char*>(numberPointer);
Exception
如果要在 C++ 中實作例外狀況 (exception) 處理，使用 try、 throw 和 catch 運算式。
開發者需要使用 try 包住可能會發生例外的程式碼區段（也就是使用 throw 丟出例外狀況的程式碼），
在 catch 處理這個 try 區域所發生的例外，並且 catch 裡面的 exception 變數應該要用 reference 的方式。
另外，如果在 catch 拿到例外狀況無法即時處理而需要丟給更上層的 try ... catch 處理，可以使用 throw 重新丟出一個例外狀況。
下面是一個例外狀況處理的例子。
#include <iostream>
#include <vector>
#include <exception>
int main()
{
std::vector<int> v = {1,2,3};
try {
std::cout << v.at(0) << std::endl;
std::cout << v.at(1) << std::endl;
std::cout << v.at(2) << std::endl;
std::cout << v.at(3) << std::endl;
} catch (std::exception &e) {
std::cout << "exception: " << e.what() << std::endl;
}
return 0;
}
C++ 並不支援 finally，因為 C++ 可以使用 RAII（Resource Acquisition Is Initialization），
也就是物件銷毀的時候也關閉或移除其使用的資源。
Namespace
C++ 可以使用 namespace 來定義名稱空間（或者開啟既存的名稱空間），例如，可以在 account.h 中定義 bank 名稱空間：
#include <string>
namespace bank {
using namespace std;
class Account {
private:
string id;
string name;
double balance;
public:
Account(string id, string name, double balance);
void deposit(double amount);
void withdraw(double amount);
string to_string() const;
};
}
在使用上，可以在 account.cpp 可以開啟 bank 名稱空間，並在其中實作類別定義：
#include "account.h"
namespace bank {
using namespace std;
Account::Account(string id, string name, double balance) {
this->id = id;
this->name = name;
this->balance = balance;
}
string Account::to_string() const {
return string("Account(") +
this->id + ", " +
this->name + ", " +
std::to_string(this->balance) + ")";
}
// ...
}
或者是在實作時指定 bank 範疇：
bank::Account::Account(string id, string name, double balance) {
this->id = id;
this->name = name;
this->balance = balance;
}
string bank::Account::to_string() const {
return string("Account(") +
this->id + ", " +
this->name + ", " +
std::to_string(this->balance) + ")";
}
名稱空間會是類別名稱的一部份，因此在使用時，必須包含 bank 前置；
或者是使用 using 來指明使用哪個名稱空間，例如：
using namespace std;
using namespace bank;
using 也可用來導入某個名稱，例如僅導入 std::string、std:cout：
#include <iostream>
#include <string>
using std::string;
int main() {
string str = "Example";
using std::cout;
cout << str;
}
C++ 其實並不建議使用 using，因為這樣如果程式碼如果大到一定規模，可能會出現命名衝突的問題。
C++ 11 Lambda Expression
Lambda expression 在 C++ 中可以視為是一種匿名函數的表示方式，它可以讓程式設計師將函數的內容直接以 inline 的方式寫在一般的程式碼之中，
使用時機跟 functor 與 function pointer 類似，一般的狀況都是使用 lambda expression 定義一個匿名的函數，
然後再將此函數當作另外一個函數的傳入參數來使用。
基本的用法如下：
[=] (int x) mutable throw() -> int
{
// 函數內容
int n = x + y;
return n;
}
[=]：lambda-introducer，也稱為 capture clause。- 所有的 lambda expression 都是以它來作為開頭，不可以省略，它除了用來作為 lambda expression 開頭的關鍵字之外，也有抓取（capture）變數的功能，指定該如何將目前 scope 範圍之變數抓取至 lambda expression 中使用，而抓取變數的方式則分為傳值（by value）與傳參考（by reference）兩種，跟一般函數參數的傳入方式類似，不過其語法有些不同，以下我們以範例解釋：
[]：只有兩個中括號，完全不抓取外部的變數。[=]：所有的變數都以傳值（by value）的方式抓取。[&]：所有的變數都以傳參考（by reference）的方式抓取。[x, &y]：x 變數使用傳值、y 變數使用傳參考。[=, &y]：除了 y 變數使用傳參考之外，其餘的變數皆使用傳值的方式。[&, x]：除了 x 變數使用傳值之外，其餘的變數皆使用傳參考的方式。
這裡要注意一點，預設的抓取選項（capture-default，亦即 = 或是 &）要放在所有的項目之前，也就是放在第一個位置。
(int x)：lambda declarator，也稱為參數清單（parameter list）。- 定義此匿名函數的傳入參數列表，基本的用法跟一般函數的傳入參數列表一樣，不過多了一些限制條件：
- 不可指定參數的預設值。
- 不可使用可變長度的參數列表。
- 參數列表不可以包含沒有命名的參數。
參數清單在 lambda expression 中並不是一個必要的項目，如果不需要傳入任何參數的話，可以連同小括號都一起省略。
mutable：mutable specification。- 加入此關鍵字可以讓 lambda expression 直接修改以傳值方式抓取進來的外部變數，若不需要此功能，則可以將其省略。
throw()：例外狀況規格（exception specification）。- 指定該函數會丟出的例外，其使用的方法跟一般函數的例外指定方式相同。如果該函數沒有使用到例外的功能，則可以直接省略掉。
-> int：傳回值型別（return type）。- 指定 lambda expression 傳回值的型別，這個範例是指定傳回值型別為整數（
int），其他的型別則以此類推。如果 lambda expression 所定義的函數很單純，只有包含一個傳回陳述式（statement）或是根本沒有傳回值的話，這部分就可以直接省略，讓編譯器自行判斷傳回值的型別。
mutable：compound-statement，亦稱為 Lambda 主體（lambda body）。- 這個就是匿名函數的內容，就跟一般的函數內容一樣。
下面是一個最簡單的 Hello World 範例。
#include <iostream>
using namespace std;
int main() {
auto lambda = []() { cout << "Hello, Lambda" << endl; };
lambda();
}
再來是 Trailing Zero-Bits 的解法：
/*
* Trailing Zero-Bits
* Given a positive integer, count the number of trailing zero-bits in its binary
* representation. For instance, 18 = 10010, so it has 1 trailing zero-bit,
* and 48 = 110000, so it has 4 trailing zero-bits.
*/
#include <iostream>
int main(void)
{
int number = 0;
auto lambda = [](int num) -> int {
int count = 0;
while((num & 1) == 0) {
count++;
num = num >> 1;
}
return count;
};
std::cout << "Please input a number: ";
std::cin >> number;
if (std::cin.fail()) {
std::cout << "It is not a number." << std::endl;
return 1;
}
if (number <= 0) {
std::cout << "Number requires > 0." << std::endl;
} else {
std::cout << lambda(number) << std::endl;
}
return 0;
}
也可以在參數列加上 void，明確標示沒有傳入參數，並將傳回值的類型設為 void，明確標示這個函數沒有傳回值：
auto lambda = [](void) -> void { cout << "Hello, Lambda" << endl; };
下面的例子是直接呼叫 lambda expression 所定義的匿名函數，將兩個參數傳入其中進行運算，最後再將運算結果傳回來：
#include <iostream>
int main() {
using namespace std;
int n = [] (int x, int y) { return x + y; }(5, 4);
cout << n << endl;
}
C++ 標準程式庫中有許多的函數在使用時會需要其他的函數作為傳入參數，最常見的就是一些對於陣列的處理函數，
這個例子是 std::count_if 最簡單的使用方式：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool condition(int value) {
return (value > 5);
}
int main() {
vector<int> numbers { 1, 2, 3, 4, 5, 10, 15, 20, 25, 35, 45, 50 };
auto count = count_if(numbers.begin(), numbers.end(), condition);
cout << "Count: " << count << endl;
}
這裡我們定義一個 condition 函數，作為 std::count_if 在判斷元素時的依據，std::count_if 會將每個元素一一傳入 condition 函數中檢查，
最後傳回所有符合條件的元素個數。
由於 std::count_if 所使用到的判斷函數都需要另外定義，這樣會讓程式碼顯得很冗長，
我們可以使用 lambda expression 改寫一下，讓整個程式碼更簡潔：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
vector<int> numbers { 1, 2, 3, 4, 5, 10, 15, 20, 25, 35, 45, 50 };
auto count = count_if(numbers.begin(), numbers.end(),
[](int x) { return (x > 5); });
cout << "Count: " << count << endl;
}
我們將原本 condition 函數所在的位置，直接使用一個 lambda expression 替換，至於傳入的參數與傳回值的類型則維持不變（傳入 int，傳回 bool）。
C++ 11 Automatic Type Deduction and decltype
In C++03, you must specify the type of an object when you declare it. Yet in many cases, an object’s declaration includes an initializer.
C++11 takes advantage of this, letting you declare objects without specifying their types:
auto x=0; //x has type int because 0 is int
auto c='a'; //char
auto d=0.5; //double
auto national_debt=14400000000000LL;//long long
Automatic type deduction is chiefly useful when the type of the object is verbose or when it’s automatically generated (in templates). Consider:
void func(const vector<int> &vi)
{
vector<int>::const_iterator ci=vi.begin();
}
而在 C++11，現在可以這樣使用：
auto ci = vi.begin();
C++11 offers a similar mechanism for capturing the type of an object or an expression. The new operator
decltype takes an expression and “returns” its type:
const vector<int> vi;
typedef decltype (vi.begin()) CIT;
CIT another_const_iterator;
C++11 也支援了 Range-based for loop，並且支援 auto 的使用，下面是一個九九乘法表的範例：
#include <iostream>
#include <vector>
int main()
{
std::vector<int> x = {1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int> y = {1, 2, 3, 4, 5, 6, 7, 8, 9};
for (auto& nx: x) {
for (auto& ny: y) {
int z = nx * ny;
std::cout << nx << " x " << ny << " = " << z << std::endl;
}
}
}
在 C++14，則可以結合 Lambda Expression 與 auto 的使用，下面是一個範例：
#include <iostream>
#include <vector>
#include <string>
#include <numeric>
int main()
{
std::vector<int> ivec = { 1, 2, 3, 4};
std::vector<std::string> svec = { "red",
"green",
"blue" };
auto adder = [](auto op1, auto op2){ return op1 + op2; };
std::cout << "int result : "
<< std::accumulate(ivec.begin(),
ivec.end(),
0,
adder )
<< "\n";
std::cout << "string result : "
<< std::accumulate(svec.begin(),
svec.end(),
std::string(""),
adder )
<< "\n";
return 0;
}
下面就是執行的結果：
int result : 10
string result : redgreenblue
IO Stream
C++ comes with libraries that provide us with many ways for performing input and output.
In C++ input and output are performed in the form of a sequence of bytes or more commonly known as streams.
- Input Stream:
If the direction of flow of bytes is from the device(for example, Keyboard) to the main memory then this process is called input.
- Output Stream:
If the direction of flow of bytes is opposite, i.e. from main memory to device( display screen ) then this process is called output.
The stream-based input/output library is organized around abstract input/output devices.
These abstract devices allow the same code to handle input/output to files, memory streams,
or custom adaptor devices that perform arbitrary operations (e.g. compression) on the fly.
Most of the classes are templated, so they can be adapted to any basic character type.
Separate typedefs are provided for the most common basic character types (char and wchar_t).
C++ 提供了 stream 的方式來看待輸出與輸入。下面的範例是讓使用者輸入 A 與 B 以後，輸出相加的數字：
#include <iostream>
int main()
{
int a = 0, b = 0;
std::cout << "Please input the name a: ";
std::cin >> a;
std::cout << "Please input the name b: ";
std::cin >> b;
std::cout << "The sum is " << a+b << "." << std::endl;
}
下面是從 /etc/os-release 讀取內容，然後取得 Linux Distribution Name 的範例：
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#ifdef _WIN32
#include <io.h>
#define access _access_s
#else
#include <unistd.h>
#endif
#ifdef ENABLE_STD
#include <filesystem>
#endif
using namespace std;
/*
* Using access function to check file exist or not
*/
bool FileExists( const string &Filename )
{
return access( Filename.c_str(), 0 ) == 0;
}
/*
* Split incoming string and return a vector
*/
vector<string> split(const string& str, const string& delim)
{
vector<string> tokens;
size_t prev = 0, pos = 0;
do
{
pos = str.find(delim, prev);
if (pos == string::npos) pos = str.length();
string token = str.substr(prev, pos-prev);
if (!token.empty()) tokens.push_back(token);
prev = pos + delim.length();
} while (pos < str.length() && prev < str.length());
return tokens;
}
/*
* get Linux distributed name: use /etc/os-release file
*/
string getListributedName()
{
string name = "";
#ifdef ENABLE_STD
std::filesystem::path p("/etc/os-release");
if(std::filesystem::exists(p)) {
#else
if(FileExists("/etc/os-release")==true) {
#endif
ifstream releasefile("/etc/os-release");
string line;
if (releasefile.is_open()) {
while ( getline (releasefile, line) )
{
auto splitArray = split(line, "=");
if(splitArray[0].compare("NAME")==0) {
name = splitArray[1];
break;
}
}
releasefile.close();
}
}
return name;
}
int main(int argc, char *argv[])
{
string name = getListributedName();
std::cout << name << std::endl;
}
C++17 加入了 Filesystem library，提供了對於 files 與 directories 的操作。
編譯：
g++ getDistributionName.cpp -std=c++17 -o getDistributionName
如果要配合 C++ standard library：
g++ getDistributionName.cpp -std=c++17 -o getDistributionName -DENABLE_STD
參考資料