iCMS

Java程序员的C++回归路(一)

好喜欢专业转载优质博客文章的地方哦~

前言:工作后吃饭的语言是java,同时写一些python和js,在学习机器学习的时候发现有必要再熟悉一下c++,同时工作也有c++的使用需求。于是开始对照c++ primer自学,希望能够对同样是其他语言的学习者,在学习c++的时候提供一些帮助。

第1章: 起始

First program

主流编译器:GNU 编译器和微软的编译器,运行微软编译器的命令是:cl

Input/Output

Using namespace used to avoid inadvertent collsions between the same names.

Std::cin返回 std::cin对象

注释

C++中有两种类型的注释:单行注释://和多行注释:/* */

如果有程序如下:

#include <iostream>


int main(){


int sum = 0,value = 0;


while(std::cin >> value){


sum += value;


}


std::cout<< "Sum is: "<< sum << std::endl;// std::endl flush buffer


}

上面这段程序会一直读取输入的内容直到输入的结尾,在不同的操作系统中,标识输入的结尾是不同的,在类unix操作系统中,使用ctrl + D来表示输入结尾,在windows系统中,使用ctrl+Z标识。

关于编译器

在类unix系统(含Mac)使用到的编译器和编译指令如下:

cc:在Mac上,cc作为clang的软链接。

clang:相比于gcc,clang有着编译速度快,编译产出小,编译提示友好等有点。而且使用c++编写,基于LLVM的C/C++/Objective C/Objective C++ 编译器。

gcc:GNU的c编译器,后面发展为可以编译很多的编程语言。

g++:c++的编译器。

msvc:windows上使用的c/c++编译器

关于这些区别的一篇博文:https://www.cnblogs.com/qoakzmxncb/archive/2013/04/18/3029105.html

C++中的类

使用一个库的时候,需要包含关联的header文件。标准库的headers一般是不包含后缀名的,编译器一般不关心文件的后缀,但是IDE有时会。

clog的使用,默认地,写到clog中的数据会被buffer缓冲,一般用于报告程序运行过程中的信息。

第2章:基础

C++的原始内建类型

C++中包含了一些基本的数学类型和void类型,作为原始内建类型。

TypeMeaningMinimum Size

bool

boolean

NA

char

character

8bits

wchar_t

wide character

16bits

char16_t

Unicode character

16bits

char32_t

Unicode character

32bits

short

short integer

16bits

int

integer

16bits(所有操作系统?)

long

long integer

32bits

long long

long integer

64bits

float

Single-precision floating-point

6 significant digits

double

Double-precision

10 significant digits

long double

Extended-precision

10 significant digits

需要注意的是,在上述表格中的数据类型所占用的内存大小根据平台的不同而不同。

确定内存地址的数据需要数据类型和读取内存地址的二进制数据,不同的数据类型决定了占用多少比特以及如何解析这些内存数据。

上述的int、long、long long类型都是有符号数,对应的无符号数前面加上unsigned。

数据类型的后缀中是U时,字面量是unsigned类型,类型可以使unsigned int,unsigned long或unsigned long long 类型;

如果后缀是L,字面量类型时long;

如果后缀是LL,字面量类型时long long 或者unsigned long long

如果后缀是UL或ULL,字面量类型时unsigned long或unsigned long long

前缀类型表:

MeaningPrefixType

u

Unicode 16 character

Char16_t

U

Unicode 32 character

char32_t

L

wide character

wchar_t

u8

utf-8

char

初始化和定义

C++提供了多种初始化的方式:


int unit = 0;


int unit = {0};


int unit{0};//列表初始化


int unit(0);

编译器不允许使用列表初始化时类型信息丢失:


long double ld = 3.1415926

Declaration & Definition

声明:声明一个名称让程序知道

定义:定义除了声明名称和类型,同时申请内存和提供默认值

为了得到一个变量的声明而不是定义,我们使用extern关键字,而且不显示的初始化变量。

extern int i; // 声明变量


int j; // 定义变量

一个变量可以被声明多次,但是只能被定义一次。

作用域

全局作用域:定义在函数体之外的变量

块作用域:{}内的作用域

复合类型

C++中有多种复合类型,这里记录指针和引用。

引用为对象起了另外一个名字,通过&d来定义引用类型,其中d是变量名


int a = 1;


int &d = a; // 声明引用,d是a的另外一个名字


int &d2; // 报错,引用必须初始化

引用非对象,相反的,它是为对象取了一个别名

为引用赋值,实际是赋值给引用的对象;获取引用的值,获取的是对象的值;将引用的值作为初始值,实际上是将引用对象的值作为初始值。

因为引用本身不是对象,所以不能定义引用的引用。

无法将引用绑定到另外一个对象,因此引用必须初始化。

可以给引用赋值(等于给别名赋值),如下代码所示:

int i = 0;


int &ri = i;


ri = 10; // legal,这里等于是给i进行赋值

指针

指针时一个指向其他类型的复合类型,值是指向对象的地址。

指针本身是一个对象。

指针值

指针的值可以指向一个对象

可以指向刚刚读取完的对象的值(类似于Iterator执行的对象)

可以是个空指针,即没有绑定任务对象

invalid指针,除了上述三种指针的值都是不合法的。

指针的指针

可以使用**p获取指针的指针所在对象的值。

void*

void*是一个特别的指针类型,可以保存任意对象的地址

在理解类似于 *&p这种类型的时候,将修饰符从右往左读去理解。

const修饰符

const修饰的类型有普通类型的大部分操作,如将const int类型转为bool类型。

int i = 0;


const int ci = i;


int j = ci;

上述代码中关于const的操作:给ci赋值的时候不会考虑ci是常量类型,因为不会改变常量的值,同样的,将ci赋值给j的时候也是如此。

默认情况下,const对象仅在文件中有效。

如果需要在不同文件间共享const变量的值,则使用extern用于声明常量并非本文件独有。

常量引用

常量的引用类型需要使用常量引用,如下所示:


const int ci = 1;


const int &ri = ci;


int &r2 = ri; // error:non const reference to a const object

const pointer

指针本身是const,例如:


int num = 0;


int *const curNum = &num; // curNum will always point to num


const double pi = 3.14;


const double *const pip = &pi; // pip is a const pointer to a const object

Top-level const

使用top-level const来标识指针本身是一个常量;如果指针指向一个const对象,那么我们说这个const是low-level const。

constexpr

常量表达式:当做const表达式时可以使用constexpr

类型处理

typedef

alias

格式为:using a = A;

auto

自动判断类型

decltype

自动判断类型,但是不计算变量的值

decltype()中的解引用操作返回的结果是引用,而不是原始类型

在decltype中添加一对以上的括号,将返回引用类型

struct

//定义struct的两种格式


struct{


};


struct {...} a,b,*c;

struct中定义的成员变量会在对象定义的时候被默认初始化。

定义头文件

一般只定义一次的内容放在头文件中,如类、const、constexpr变量等。

头文件一旦改变,相关的源文件需要重新编译来获取新的变量声明。

确保头文件多次包含仍能被正确处理的机制是预处理器(preprocessor)

预处理器看到#include会将内容替换掉#include

头文件保护符:使用以下代码来避免重复包含的发生:

#ifndef CPP_TEST_SALES_DATA_H


#define CPP_TEST_SALES_DATA_H


struct sales_data{



};


#endif //CPP_TEST_SALES_DATA_H

与编译器无视关于作用域的规则

一般的做法是基于类的名字来构建保护符的名字

字:在指定机器上进行整数运算的自然单位

字符串、vector

using

格式为:using namespace::name

头文件不应该包含using描述,否则可能有名字冲突。

C++中将一个标识符定义为一个字符串,源程序中的标识符用字符串代替。如:

#define ADD (x,y) x+y


result=ADD(2,3); // 使用 x+y替换

string

初始化string的方式

string s(4,'c') // 初始化为"cccc",直接初始化


string s2("hello") // 直接初始化


string s3 = "hello" //拷贝初始化


其他初始化方式省略

string的操作

getline(is,s) //从is中返回一行赋值给s,返回is


其他操作省略

string::size_type类型

string.size() // 返回string.size_type,实际上是一个无符号整型数

string +


string cs1 = "hello";


string cs2 = cs1 + "," + "world";


// string cs3 = "hello" + "world" + cs1; // 不能直接使用字面量相加

不能直接使用字面量相加,因为由于历史原因,字符串字面值与string不是相同的类型

string 字符的操作

使用for循环迭代操作string中的字符,注意如果需要修改字符,需要使用引用,如下所示:

string fs("Hello,world");


for (auto &item : fs)


item = toupper(item);


std::cout << fs << std::endl; // 输出HELLO,WORLD

使用索引来访问字符串中的元素,需要注意的是,索引的类型也是 string::size_type

在c++标准中并不要求检查下标是否合法,如果一个下标超出了范围,则可能有不可预知的后果。

vector的初始化

c++提供多种初始化方式

vector<int> v1 = {1,2,3} // 拷贝初始化


vector<int> v2 {1,3} // 列表初始化


vector<int> v3(10,1) //初始化10个1

vector的长度: size函数返回的是vector对象中元素的个数,类型是vector<xxx>:size_type类型

试图用下标的形式访问一个不存在的元素将引发错误,不过这种错误不会被编译器发现,而是在运行时产生一个不可预知的错误。(例如缓冲区溢出(buffer overflow))

迭代器

使用迭代器:使用begin和end函数返回迭代器,其中begin成员负责返回指向第一个元素的迭代器,end成员函数返回指向容器(或string对象)尾元素的下一位置。

迭代器的*iter操作返回的是迭代器iter的引用??是否可以将iter本身理解为引用?

string sv = "some thing";


if(sv.begin() != sv.end()){


auto it = sv.begin();


*it = toupper(*it); // 使用*操作符解引用


}

泛型编程:

在c++的for循环中,经常使用!=来替代java中的<=作为判断是否跳出循环,这个是因为在c++的标准库中,很多的容器类提供了!=的运算符而没有<运算符,而很多时候又使用iterator来遍历容器。

迭代器类型

如size_type一样,我们一般不关心迭代器的具体类型。可以是iterator或者const_iterator。

使用新标准中提供的cbegin()和cend(),返回const类型的iterator

Dereference和member

以(*iter).empty为例,*iter的括号是必须的。如果没有括号的话将会被解析为iter.empty member,而iter是一个迭代器没有empty member。

于此同时,c++中提供了->运算符,这个就等于(*it).

使用iterator的不能使用iterator.add()来添加元素到容器中。

vector和string提供了额外的操作,如下表所示:

使用iterator的减法返回有符号数类型的difference_type

值得注意的是,迭代器只定义了减法运算而没有加法运算。

Array

字符数组

由于字符串由''结束,所以在初始化char型数组时需要比字面量空间更大。

数组的初始化必须是一个初始化列表,不能用一个数组给另一个数组赋值,如下:

int[] a = {1,3};


int[] a2 = a; // Error,不能使用数组赋值

复杂的数组声明

int (*Parray)[10] = &arr; // Parray是一个指针,指向大小为10的数组,数组类型为int

int (&arrRef)[10] = arr; //arrayRef是一个引用,引用的对象是一个大小为10的int类型的数组

在理解复杂的数组声明时,使用由内而外的理解方法去理解。

Eg: int *(&array)[10] = ptrs; // array是一个引用,引用的对象是10个int类型的指针(Reference to an array of ten pointers)

通过下标访问数组

通常使用sizt_t类型来定义数组的长度。

数组和指针

一般情况下,我们使用数组,编译器会自动将指针指向数组的第一个元素。

string nums[] = {"1","2","3"};


string *p = &nums[0];


string *p2 = nums; //equivalent to p2 = &nums[0]

使用auto和decltype的类型:

int ia = [1,3];


auto ia2(ia2);


auto ia2(&ia[0]); // ia2的类型是int*

C++11中引入了新的获取起始指针和尾指针的函数:begin()和end(),包含在iterator header

两个指针相减的结果是ptrdiff_t,类似于size_t,定义在cstddef header中。

可以使用指针来操作数组,参照如下例子:


int *p = &ia[2]; // p points to the element indexed by 2


int j = p[1]; // p[1] is equivalent to *(p+1)


int k = p[-2]; // equivalent to ia[0],可以使用减法指向之前的元素

内建的数组下标可以是负数,而vector等类型的下标必须是无符号数

c语言中的string

在c标准库中定义了一种字符串的convention,以''结尾,定义在<string.h>中(对应c++中的cstring)

并且c标准库中提供的函数并不会校验传入的字符数组是否合法,这可能会引发一些问题。

对于指针来说,如果指针指向的不是同一个对象,那么指针之间的比较就没有意义。

c语言中的字符串示例:

const char ca1[] = "Hello";


const char ca2[] = "World";


if(ca1 < ca2) // undifined comparison。由于实际上是指向不同对象的两个指针做比较

c语言字符串和c++字符串之间的互相使用:

可以使用c语言中的null itermiated char数组,用于初始化字符串

可以将c语言中的字符串用作操作数

c++中提供c_str()成员函数,用string初始化char[]

第4章:表达式

基础

左值和右值

一个左值表达式的求值结果是一个对象或者一个函数。

当一个对象被用作右值时,使用的是对象的值,当一个对象用作左值时,使用的是对象的地址(在内存中的位置)

值溢出


short short_value = 32767; // max value


short_value ++;


std::cout << "short_value:" << short_value << std::endl; // 发生了溢出,不同的系统上结果可能不一样(设置可能直接崩溃),值得记录的是,java的现象跟c++是一致的。运行结果是-32768

c++中支持使用:not来作为非条件。

第5章: Statement

第6章: 函数

try 块

如果抛出了异常而且没有合适的catch处理,则最终执行terminate函数,具体的处理方法与系统相关

参数

const参数

在函数定义时,使用const和不使用const是一样的,因为使用const,顶层的const会被忽略掉。

关于const指针、引用参数的一些例子:

int i = 42;


const int *cp = &i; //正确,但是不能用cp改变i的值


const int &r = i; //正确,但是不能用r修改i的值


const int &r2 = 42; //正确,指向常量


int *p = cp; // 错误,指针类型不匹配


int &r3 = r; // 错误,类型不匹配


int &r4 = 42; // 错误,不能指向常量

可变形参的函数

c++支持initializer_list形参,支持同种类型不同个数的参数

同时支持可变长参数,但是一般仅仅用于和c语言交互的接口,因为很多对象不能正常的拷贝。

不要返回局部对象的引用或指针,否则将指向不可用的地址空间或对象

返回数组指针

int *p[10] :10个指针的数组

int (*p)[10]:一个指针,指向10个整数数组

返回数组指针的方式:

typedef

声明一个返回数组指针的函数

使用尾指针返回类型(auto func(int i)-> int(*)[10])

使用decltype

引用与之类似

调试帮助

Assert 宏

assert由preprocessor处理而不是编译器,所以使用assert时是直接使用。

NDEBUG预处理变量

当使用

#define NDEBUG

在文件开始处时,代码中的assert将不起作用,同时也可以在命令行中使用-D NDEBUG来设置。

除此之外,还可以使用NDEBUG来编写一些根据NDEBUG的值判断是否执行的代码:

#ifndef NDEBUG


#endif

如果NDEBUG没有定义,则上面块中的代码将被执行。

C++预处理器提供了一些用于调试的变量:

__func__ 当前函数

__FILE__ 当前文件

__LINE__ 当前行

DATE 编译日期

TIME 编译时间

重载

函数重载的选择:所有数学转换优先级都是相等的,如:

void test(float f);


void test(long l);


//调用test(1)时会出现ambiguous

C++中不能将const类型的引用赋值给普通类型的引用(暂时可以助记为初始化常量引用时的限制没有普通引用多)

函数指针

定义类型: bool (*pf)(const string&)

可以直接使用函数指针来调用函数,而不需要进行解引用:

bool (*pf)(const string&);


pf("hello");


(*pf)("hello");

给函数指针赋值时,需要返回值类型和参数类型完全一致才可以赋值,函数指针之间不存在指针的转换

函数指针指向重载函数时,需要指定具体使用的函数,通过确定的变量

函数指针作为参数,可以直接使用函数作为参数,该函数实际上会作为一个指针来处理:

void test(bool pf(const string&));


void test(bool (*pf)(const string&));

或者,也可以使用typedef和decltype来简化代码:

//Func和Func2是函数类型


typedef bool Func(const string&);


typedef decltype(test) Func2;



//Funcp和Funcp2是函数指针类型


typedef bool(*Funcp)(const string&);


typedef decltype(test) *Funcp2;

返回指针类型


//声明函数指针


using F = int(int*); // F是一个函数类型,而不是一个函数指针


using PF = int(*)(int*); // PF是函数指针


//定义函数指针


PF f1(int);


F *f1(int);


//上面的定义等于:


int (*f1(int))(int*);


//可以使用auto和decltype


auto f1(int) -> int(*)(int*)

例子:

string::size_type sumLength(const string&,const string&){



}



string::size_type largerLength(const string&,const string&){



}


decltype(largerLength) *getFunc(const string&); //传入函数名来获取函数指针

0

上一篇:

:下一篇

精彩评论

暂无评论...
验证码 换一张
取 消