C++&Golang Coding

image.png

https://blog.csdn.net/u011185231/article/details/51591571
1、在C++，不同类型的指针是不能直接赋值的，必须强转

[cpp] view plain copy

void *p;
int *i = (int *)p;

2、class是C++的核心，也是面向对象的核心基础

[cpp] view plain copy

class Person
{
public:
string name;
private:
int age;
public:
int sex;
};

3、引入了命名空间防止大型项目中代码冲突

4、new关键字的使用

[cpp] view plain copy

int *p = new int;
*p = 100;
//分配内存的时候可以同时赋值，前两句代码相当于 int * p = new int (100);
cout << *p << endl;//输出100
delete p;//用完记得删除, 用new分配的内存必须用delete释放，不能用free
int *p = new int[10];//用new创建数组
//删除的时候不能这样写：delete p; 这样写是删除了数组中第一个地址,会造成内存泄漏;
delete []p;

5、inline 内联关键字的作用：内联函数不用为函数调用，而是直接把函数的代码嵌入到调用的语句中。

[cpp] view plain copy

int main(){
for ( int i = 0 ; i < 100; i++)
{
int a = max (i , 50 );
}
return 0 ;
}
inline int max (int a, int b ){
if ( a > b)
return a ;
else
return b ;
}
//inline函数适合用在代码少，且大量的调用的函数。

6、引用:一个变量的别名，不是一个变量的地址

[cpp] view plain copy

int main(){
int a = 1 ; int b = 2 ;
int & c = a; //正确,c就是a的别名
c = b; //错误，不能修改
int & c;
c = a; //错误,c不能单独命名
swap ( a , b );
cout << "a = " << a << endl ; // a = 2;
cout << "b = " << b << endl ; // b = 1;
return 0 ;
}
void swap( int & a , int & b ){
int temp = a ;
a = b;
b = temp;
}

7、函数的默认实参

[cpp] view plain copy

void Func( int a = 100 ){
cout << "a = " << a << endl ;
}
int main(){
Func (); // 打印 a = 100;
return 0 ;
}

8、函数重载:函数名字相同，只是参数不同

[cpp] view plain copy

void Func(){}
void Func( int a ){}
void Func( string str ){}

9、模板函数

[cpp] view plain copy

template <class T>
T Add( T a , T b)
{
return a + b ;
}
int main()
{
int a = 1;
int b = 2;
Add( a , b );
return 0;
}

10、private，public，protected

在类里面如果没有权限限定符，默认是private

在结构体里面没有权限限定符，默认是public

11、一个unsigned int类型与int类型相加的结果是一个unsigned int类型。

[cpp] view plain copy

int main()
{
int unsigned a = 1 ;
int b = - 2;
std ::cout << a + b << std :: endl;//输出的类型是一个unsigned int类型，输出结果为：4294967295
}

12、两个字符串位置相邻，实际上是一个整体。

[cpp] view plain copy

std :: cout << "asdfasdf" "asdfasdf" "ASdfasd" << std:: endl ;
//输出的是一个整体

13、定义在函数体内部的内置类型变量不会被初始化，定义在函数体外部的内置类型变量会自动初始化。

[cpp] view plain copy

int main()
{
int a ;
std ::cout << a << std:: endl ;
return 0 ;
}
//程序会报错,提示局部变量a未被初始化。

14、extern关键字

[cpp] view plain copy

extern int i;//声明i
int j;//声明并定义j
extern int k = 1;//定义

15、引用就是别名，引用不是对象，它只是一个已存在的对象的别名，一旦绑定一个对象之后就无法再绑定其他对象。

[cpp] view plain copy

int main()
{
int b = 0;
int &a = b ;//a指向b
int &c;//报错,引用必须初始化
int &d = 1;//报错,引用只能绑定到对象上。
std ::cout << &b << std :: endl;
std ::cout << &a << std :: endl;//a和b都指向同一个地址
return 0 ;
}

16、void*是一种特殊的指针类型，可以存储任意对象的地址。

[cpp] view plain copy

int main()
{
int val = 0 ;
void *a = &val ;//合法
long *b = &val;//非法
}

17、const对象在默认情况下只在本文件内有效。若要共享const对象，就必须在前面加上extern关键字

[cpp] view plain copy

extern const int val = 0;//定义了并初始化了一个常量，这个常量可以在其他文件中使用。
extern const int val;//声明了一个val，说明val并不是本文件独有的，它的定义在别处。

18.const指针

[cpp] view plain copy

int main()
{
int val = 1 ;
int num = 2 ;
int * const p = & val; //p是一个const指针，p将一直指向val，可以修改所指对象的值（也就是val的值）
p = &num ; //错误，p是一个const指针
const int num1 = 1 ;
const int *const p1 = & num1 ;//p1是一个指向常量对象的常量指针，既不能指向其他地址，也不能修改所指对象的值（也就是num1的值），
}
//如果表达式太复杂，可以通过从右往左阅读来弄清楚。拿上面例子来讲：p旁边的符号是const，说明p是一个常量对象，再往左的符号是*，表示p是一个常量指针，再往左是int，则说明p是一个指向int类型对象的常量指针。
//通过上面方法可以得知p1是一个指向int类型常量的常量指针。

19、关于指向常量的指针和引用。

[cpp] view plain copy

int main()
{
int val = 1 ;
const int *p1 = & val; //正确，可以指向一个非常量对象
const int &a = val ; //正确，可以绑定一个非常量对象
}
//1、指向常量的指针可以指向非常量，但不可以通过该指针来修改这个非常量的值。
//2、常量引用也可以绑定非常量对象，但是不可以通过该引用来对绑定的这个对象作出修改。

20、字符串的几种初始化方法，一般使用常用方法即可。

[cpp] view plain copy

int main()
{
string s = "aaaa" ; //常用
string s1 ( 10, 'a') ;//输出10个a
string s2 = { "aaaa" };
string s3 = ( "aaaa" );
string s4 ( "aaaa" );
string s5 = ( "aaaa" );
string s6 = string( "aaaa" ) ;
}
//若使用=来初始化则表示拷贝初始化，不使用=初始化表示直接初始化

21、getline会读取一整行，如果希望在得到的字符串中保留空格，就用getline替换>>运算符。

[cpp] view plain copy

int main()
{
string s ;
while ( getline (cin , s))//读入一整行直到遇到文件末尾
{
cout << s << endl ;
}
return 0 ;
}

22、字面值和string对象相加时，必须确保加号两边至少有一个是string对象

[cpp] view plain copy

int main()
{
string s1 = "1" ;
string s2 = "1" + "2"; //错误,加号两边都是不是string对象
string s3 = s1 + "1"; //正确,加号左边是一个string对象
string s4 = "1" + "2" + s1 ; //错误,第一个加号两边都不是string对象
string s5 = s1 + s2; //正确,加号两边都是string对象
return 0 ;
}

23、标准库类型vector表示对象的集合，是一个类模板

[cpp] view plain copy

int main()
{
vector <int > a ;
vector <vector < int>> b;
return 0 ;
}

image

vector对象能够高效的增长，所以在定义的时候设定大小是没有必要的，甚至性能更差。但是如果所有初始元素都是一样的值的话是可以在定义的时候初始化的。

[cpp] view plain copy

int main()
{
vector <int > vInt = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };
for ( auto &i : vInt )
{
i *= i;
}
return 0 ;
}
//与string类型一样，若要改变元素的值，需要在循环的时候对循环变量定义为引用类型

24、迭代器

[cpp] view plain copy

int main()
{
string s = "asdfasdfasfd" ;
auto a = s .begin (); //a表示第一个元素
auto b = s .end (); //b表示尾元素的下一个元素
cout << *a << endl;//打印结果是输出'a'
cout << *b << endl;//错误，因为b是指向尾元素的下一个元素,没有实际指向一个元素,所以不能对他进行解引用或者递增操作
vector <int > vInt ( 10, 1 );
auto c = vInt .begin ();
auto d = vInt .end ();
return 0 ;
}

[cpp] view plain copy

容器运算符
*iter 返回该迭代器所指元素的引用
iter->men 返回该迭代器所指元素中名为men的成员,可写成(*iter).men;
++iter 指向该迭代器的下一个元素
--iter 指向该迭代器的上一个元素
iter1 == iter2 判断两个迭代器是否相等,如果两个迭代器指向的是同一个元素或者两个迭代器都指向同一个容器的尾后迭代器，说明相等;反之不相等。
iter1 != iter2

对于迭代器和vector对象的使用上的注意事项：

1、vector对象可以动态的增长，所以这也限制了使用for（rangefor）来循环对vector中push_back元素。

2、另一个就是：如果定义了一个vector的迭代器，之后再向vector对象中push_back元素的话，原迭代器会失效。

[cpp] view plain copy

int main()
{
vector <string > vStr;
auto a = vStr.begin ();//初始化之后立即定义一个迭代器
vStr.push_back ( "11" );
vStr.push_back ( "22" );
auto b = vStr.begin ();//push_back元素之后重新等一个迭代器
cout << *a << endl;//报错，因为vStr为空，a是指向尾迭代器
cout << *b << endl;//成功，b是指向第一个元素
return 0 ;
}

25、字符数组有一种额外的初始化方式。

[cpp] view plain copy

int main()
{
char a[] = { 'c' , '+' , '+' , '\n' };
char b[] = "c++";
char c[4] = "c++";
//这3种初始化方式效果是一样的
return 0 ;
}

26、指针也可以实现迭代器的功能，但必须得指定头指针和尾后指针，但不安全，c++11提供了新方法：begin()和end()

[cpp] view plain copy

int main()
{
const int size = 10 ;
int arr[size] = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };
int *pHead = arr;
int *pEnd = &arr[size];//arr[size]这个元素并不存在，所以递增操作或者也不能解引用来取值，这里唯一的用处就是提供其地址用于初始化pEnd。
for ( int *p = pHead ; p != pEnd ; ++p)
cout << *p << " " ;
cout << endl;
return 0 ;
}

27、c风格的字符串操作

[cpp] view plain copy

int main()
{
char a [] = { '1' , '2' };
cout << strlen( a ) << endl ;//错误，没有以空字符结束
char b[] = "11111 22222";
char d[] = "22222 11111";
strcmp(b, d);//如果b>d返回真值，如果b<d返回负值
char s[100] = {}; //初始化一个用于存放结果的数组
strcpy(s, d);//把d复制给s
strcat(s, d);//把d加在s的后面
char *p = s;
while ( *p )
{
cout << *p << endl ;//输出操作结果
p++;
}
return 0 ;
}
//对于大多数应用程序来说使用标准库string比c风格字符串更安全高效

[cpp] view plain copy

//string对象转换为c风格字符串
int main()
{
string s = "11111111" ;
const char *cc = s .c_str();
return 0 ;
}
//使用数组初始化vector对象
int main()
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 };
vector <int> vInt1 ( begin( arr ), end (arr) );//把数组的值全部用于初始化vector对象
//也可以用数组的一部分值来初始化
vector <int> vInt2 ( arr + 1, arr + 3 );
vector <int> vInt3 ( begin(arr) + 1, end(arr) - 1);
return 0 ;
}

28、用指针来遍历多维数组。

[cpp] view plain copy

int main()
{
int arr[3][4] = {
1, 2, 3, 4,
5, 4, 3, 2,
1, 13, 3, 4
};
for ( auto p = arr ; p != arr + 3 ; ++p )//先循环一维得到一维的地址
for ( auto d = *p; d != *p + 4; ++d )//根据一维的地址得到二维地址，并输出值
cout << *d << " " ;
return 0 ;
}
//也可以使用标准函数begin()和end()来实现相同功能,更简洁安全
int main()
{
int arr[3][4] = {
1 , 2 , 3 , 4 ,
5 , 4 , 3 , 2 ,
1 , 13 , 3 , 4
};
for ( auto p = begin (arr ); p != end (arr ); ++ p )
for ( auto q = begin (p ); q != end (p );++ q)
cout << *q << " " ;
return 0 ;
}

29、关于递增递减运算符的选用

[cpp] view plain copy

int i = 0; j = 0;
j = ++i;//前置版本,i = 1; j = 1 //改变i的值并返回给j
j = i++;//后置版本,i = 2; j = 1 //存储i的值并计算返回j
//尽量选用前置版本的递增递减运算符：
//1、后置版本的需要将原始值储存下来以便返回这个未修改的内容，如果我们不需要这个未修改的内容，那么这个后置版本的操作就是一种浪费。
//2、基于上面的原因，对于整数和指针类型来说，编译器可能会对这种工作进行一定的优化，但对于相对复杂的迭代器类型来说，这种额外的工作是非常耗性能的。

30、sizeof运算符返回一条表达式或者一个类型名字所占的字节数，它不会求实际类型的值

[cpp] view plain copy

sizeof(type)
sizeof expr//返回表达式结果类型的大小
int main()
{
string s , * p ;
sizeof( string );//返回string类型的对象的大小
sizeof s;//s类型的大小，与上面一样
sizeof p;//指针所占空间大小
sizeof *p;//因为sizeof不会求实际类型的值，所以即使p没有初始化也没有影响
return 0 ;
}
//对string和vector对象执行sizeof运算只返回该类型固定部分的大小，不会计算对象中的元素占用了多少空间

31、算术转换的规则是运算符的运算对象转换成最宽的类型，如：

** 1、**一个运算类型是long double，那么不论另一个运算类型是什么都会转换为long double。

 **2、**当表达式中有浮点型也有整型时，整数类型将转换为浮点型。

32、显示转换

[cpp] view plain copy

1、旧版的强制类型转换
type (expr)//函数形式的
type expr//c语言风格的
int main()
{
int i = 11 , j = 2;
double res1 = double (i ) / j;
return 0 ;
}
2、新版的强制类型转换
cast-name<type>(expr)
cast-name分别有:static_cast、dynamic_cast、const_cast和reinterpret_cast
static_cast:任何具有明确定义的类型转换，只要不包含底层const，都可以使用它。
dynamic_cast:支持运算时类型识别。
const_cast:只能改变运算对象的底层const。
reinterpret_cast:通常为运算对象的位模式提供较低层次上的重新解释。
int main()
{
int i = 11 , j = 2;
//使用static_cast
double res = static_cast <double> (i) / j ;
void *d = & i;
int p = static_cast <int> (d);
//使用const_cast
const char *pc ;
char cp = const_cast <char> (pc);
//使用reinterpret_cast
int *pi;
char ic = reinterpret_cast <char> (pi);
string str = ic;//错误,ic实际存放的是指向int类型的指针
return 0;
}

33、局部静态对象：如果我们想让一个局部变量的生命周期贯穿函数以及之后的时间。我们可以把变量定义为static类型，局部静态对象在程序执行第一次经过对象时被初始化，直到程序运行终止时才销毁。

[cpp] view plain copy

int count()
{
static int res = 0 ;
return ++res ;
}
int main()
{
for ( int i = 0 ; i < 10; ++i )
cout << count() << endl;
return 0 ;
}

34、建议变量和函数的声明放在头文件中，在源文件中定义。

35、在拷贝大的类类型对象或者容器对象时是比较低效的。而且有些类类型对象还不支持拷贝。所以使用引用是非常明智的选择。

[cpp] view plain copy

//使用引用来比较
bool isShorter( string &s1, string &s2 )
{
return s1.size() < s2.size();
}
//使用拷贝来比较
bool isShorter( string s1, string s2 )
{
return s1.size() < s2.size ();
}
//使用常量引用来比较，如果函数不用修改形参的值，最好使用常量引用
bool isShorter( const string &s1, const string &s2 )
{
return s1.size() < s2.size();
}
int main()
{
string s1 = "111111" ;
string s2 = "11111111" ;
cout << isShorter( s1, s2 ) << endl;
return 0;
}

36、函数的数组形参，数组有两个特性：(1)不允许拷贝数组。(2)使用数组时会转为指针

[cpp] view plain copy

void set(const *int);
void set(const int[]);
void set(const int[20]);//这里的20表示期望含有多少元素，实际上不一定。
//上面3中表达方式是等价的，都是const *int类型的形参
int i = 0;
int j[2] = {1, 2};
set( &i );//正确
set( j );//正确

37、函数中管理指针的3中方法

[cpp] view plain copy

第一种方法：必须要求数组本身包含结束标记
void set( const char *p )
{
if ( p )
while (* p )
{
cout << *p ++ << endl;
}
}
void set(const int *p)
{
if(p)
{
while(*p)
cout << *p << endl;
}
}
//这用方法用于有结束标记的情况如char类型。如果用于int类型就会无效。
第二种方法：是传递一个数组的首元素和尾后元素的指针
void print( const int *begin , const int *end)
{
while ( begin != end)
{
cout << *begin ++ << endl;
}
}
int main()
{
int i[] = { 1, 2 , 3 };
print (begin (i), end(i));
return 0 ;
}
第三种方法：是在函数的形参中添加一个表示数据大小的形参，在以前c和c++的程序中经常使用这种方法
void print( const int *p , const int size )
{
for ( int i = 0 ; i < size; ++i )
{
cout << *(p + i ) << endl ;
}
}
int main()
{
int i [] = { 1 , 2 , 3 };
print (i , end ( i) - begin (i ));
return 0 ;
}

38、多维数组就是数组的数组

[cpp] view plain copy

//p指向数组的首元素,该元素是包含10个整数的数组
void set(int (*p)[10], int rowSize){}
//等价于
void set(int p[][10], int rowSize){}

39、返回引用的函数

[cpp] view plain copy

char & get_value (string &s , int index)
{
return s [ index] ;
}
int main()
{
string s = "11111" ;
get_value (s , 0 ) = '2';
cout << s << endl ;//输出21111
return 0 ;
}

40、返回数组指针的函数

[cpp] view plain copy

func(int i)//表示调用func时需要一个int型实参
(*func(int i))//表示可以对该函数的结果解引用
(*func(int i))[10]//表示解引用该函数将得到一个大小为10的数组
int (*func(int i))[10]//表示数组中的元素是int类型

41、函数指针：函数指针指向的是函数，函数类型由它的返回值类型和形参类型共同决定。

[cpp] view plain copy

如：bool compare( const string & , const string &);
则该函数的类型是bool( const string &, const string &),
则指向该函数的指针是：bool (*p)( const string &, const string &)
//函数的重载指针
void set( int *);
void set(char *);
void (*p)( int * ) = set; //p默认指向了 set(int *)
//声明语句直接使用函数指针显得冗长，可以使用typedef来简化。
//下面四个是等价声明
typedef void func1(int *); //func是函数类型
typedef void (*funcp1)(int *);//funcp是函数指针
using func2 = void( int *);
using funcp2 = void(*)(int *);
使用的时候直接:
void use(int a, int b, func);
void use(int a, int b, funcp);
//用容器把函数存储起来
int add( const int & a , const int & b )
{
return a + b ;
}
int reduce( const int & a , const int &b )
{
return a - b ;
}
int multiply( const int &a , const int & b)
{
return a * b ;
}
int divide( const int &a , const int & b)
{
return a / b ;
}
using p = int (*)( const int &, const int &);
vector b{ add, reduce, multiply, divide } ;
int main()
{
for ( auto a : b )
{
cout << a( 1, 2) << endl ;
}
return 0 ;
}

42、如果一个类允许其他类或者函数访问它的非公有成员，可以让这个其他类或者函数成为他们的友元。

[cpp] view plain copy

class Person
{
friend istream & read ( istream& is , Person& person );//友元的声明仅仅指定了访问权限
private :
string name;
string address;
};
inline istream& read( istream& is, Person& person)
{
is >> person.name >> person.address;//虽然name和address是私有变量，但是成为友元之后可以访问。
return is;
}

43、如果我们希望能修改类的某个数据成员，即使在一个const成员函数中，我们可以通过在数据成员的声明前加上mutable关键字

[cpp] view plain copy

class Person
{
public :
void Total () const;
private :
mutable int sum;
};
void Person:: Total () const
{
++sum;
}

44、要想让某个成员函数作为友元，必须按顺序来设计程序。以满足声明和定义的依赖关系。

[cpp] view plain copy

1.首先定义Manager类，其中声明clear函数，但不定义它。在clear使用Screen之前必须先声明Screen
2.然后定义Screen，包括对clear友元声明
3.最后定义clear，这样才能正常使用Screen的成员。

[cpp] view plain copy

</pre><pre code_snippet_id="1708766" snippet_file_name="blog_20160605_46_4473679" name="code" class="cpp"><pre name="code" class="cpp">class Screen;
class Manager
{
public :
using ScreenIndex = vector < string>:: size_type ;
inline void clear( ScreenIndex );
private :
vector <Screen > screens ;
};
class Screen
{
friend void Manager:: clear (ScreenIndex );
//friend class Manager;
private :
pos width = 0 ;
pos height = 0 ;
pos cursor = 0 ;
string contents ;
};
inline void Manager::clear ( ScreenIndex index )
{
if ( index > screens.size()) return;
Screen & sc = screens[index];
sc.contents = string( sc.width * sc.height, ' ' );
}

45、当在类的外部定义成员函数时,必须提供类名和函数名

[cpp] view plain copy

void Manager::clear ( ScreenIndex index )//因为提供了类名，所以我们可以直接使用类中其他的成员:ScreenIndex、screens等
{
if ( index > screens.size()) return;
Screen & sc = screens[index];
sc.contents = string( sc.width * sc.height, ' ' );
}
//但如果是在函数返回值要使用类中的成员，就必须指明这个返回值是属于哪个类的
Screen::pos Screen::size() cosnst
{
return height * width;
}

46、如果类的成员是const、引用、或者属于某种没有提供默认构造函数的类类型，我们必须通过构造函数初始值列表为这些成员提供初值。

[cpp] view plain copy

class Test
{
public :
//这个版本的构造函数是对数据成员执行赋值操作
Test (int a, int b , int c )
{
val1 = a; //正确
val2 = b; //错误,不能给const赋值
val3 = c; //错误,val3没有初始值
}
//下面这个版本是显式的初始化引用和const，是正确做法
//Test(int a, int b, int c) :val1(a), val2(b), val3(c){}
private:
int val1;
const int val2;
int &val3;
};
//最好使用第二个版本

47、类成员的初始化顺序是由它们在类中定义的顺序决定的

[cpp] view plain copy

class Test
{
int i;
int j;
public:
Test(int val ) : j(val),i(j){} //这里i会先初始化，j后初始化，这样初始化的结果是用一个未定义的j来初始化i，这种做法是错误的，我们应该尽量避免这种情况。
}

48、声明一个用默认构造函数初始化的对象常犯的错

[cpp] view plain copy

int main()
{
Person person1(); //声明并初始化一个函数，不是对象
Person person2; //定义了一个对象，并使用默认构造函数初始化
return 0 ;
}

49、C++中的隐式类类型转换:如果构造函数只接受一个参数，那么它们就默认定义了这个类类型的隐式转换机制。

[cpp] view plain copy

int main()
{
Sales_Data item1 ;
string newBook = "11111" ;
item1.combine(newBook);//合法的，这里的combine实际上是一个接受Sales_Data类型的函数，但在这里却接受了一个string类型：它是先构建一个临时的Sales_Data类型的对象，然后把newBook作为构造函数的参数传给这个临时的Sales_Data对象，然后再把这个临时对象传给combine
Sales_Data item2 = "111111" ;//正确，拷贝初始化
item1.combine("11111");//错误的，是因为只允许一次类类型转换，而这里是先把字符串转换成string,然后再把这个临时的string转换成Sales_Data对象，执行了二次类类型转换，所以是错误的。
return 0 ;
}
//如果我们想禁止隐式类类型转换，可以在构造函数的声明出使用explicit关键字
explicit Sales_Data ( const string s ) : bookId (s ){}
explicit Sales_Data ( istream& is );

最后编辑于：2018.05.14 23:44:31

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,324评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,303评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,192评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,555评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,569评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,566评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,927评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,583评论 0赞 257
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,827评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,590评论 2赞 320
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,669评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,365评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,941评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,928评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,159评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,880评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,399评论 2赞 342

C++&Golang Coding

推荐阅读更多精彩内容