linux C++ day3

最新推荐文章于 2024-06-11 20:49:12 发布
最新推荐文章于 2024-06-11 20:49:12 发布
阅读量124 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40632341/article/details/104257383
版权

引用==》引用型返回值==》{返回左值 不能返回局部变量的引用}
常引用型返回值==》返回右值
引用型返回值
返回左值
值形式的函数返回值通常都具有右值属性，即在函数的调用者空间根据函数的返回类型创建一个匿名对象，负责接收该函数的返回值
用于接收函数返回值的匿名对象和表达式的值类似，通常只具有语句级生命期且只能，即所谓将亡右值
如果函数返回的是一个引用，那么用于接收该返回值的就不再是一个匿名的将亡右值对象，而是一个引用该函数所返回的目标对象的引用，甚至可以是左值引用
函数返回的左值引用可与其他任何形式的左值一样，参与包括赋值，复合赋值，自增减等在内的各种左值运算

不能返回局部变量的引用
函数的局部变量只具有函数级甚至块或语句块的生命周期，函数一旦返回，所有的局部变量即刻销毁，即使通过返回值获得了对他们的引用，其目标也将是未定义的
–int& foo(void){int n=123;return n;}//危险
int* bar(void){int n=456;return &n;}//危险
int hum(void){int n=789;return n;}
–int& foo(int& n){return n;}
int& bar(int* n){return n};
int& hum(int n){return n;}//危险
–int foo(int& n){return &n};
int* bar(int* n){return n;}
int* hum(int n){return &n;}//危险

常引用型返回值
返回右值
值形式的函数返回值天然具有右值属性，但从函数返回值跟通过值向函数传参数一样，伴随着对象的复制过程
–int foo(void){…}
foo()=1234;//错误
为了避免对象复制的开销，同时又不想失去作为函数返回值的右值属性，可以返回一个常左值引用，模拟或者逼近右值的使用效果
–int& foo(void){…}
foo()=1234;
–int const& foo(void){…}
foo()=1234;//错误

类型转换==》显式类型转换==》静态类型转换，动态类型转换，去长类型装换，重解释类型转换
静态类型转换
static_cast<目标类型>（源类型对象）
–编译器对源类型和目标类型做相容性检查，检查不通过报错
–源类型和目标类型只要在一个放向上可以做隐式类型转换，那么在两个方向上就都可以做静态类型转换
–如果将目标类型从源类型的类型转换构造函数，或者源类型向目标类型的类型转换运算符函数，被声明为explicit,那么从源类型到目标类型的类型转换就必须显式完成，静态类型转换可用于这样的场合

动态类型转换
dynamic_cast<目标类型>（源类型对象）
–编译器首先检查源类型和目标类型是否同为指针或引用且其类型之间存在具有多态性的继承关系，不存在直接报错
–编译器生成一段指令，运行时执行该指令，检查源和目标的类型是否一致，不一致通过返回空指针或抛出异常报错
–常被用于具有多态继承关系的父子类对象的指针或引用之间的转换
==》将泛型指针转换为具体指针

去常类型转换
const_cast<目标类型>（源类型对象）
–编译器检查源类型和目标类型是否同为指针或引用，且其目标类型之间除常属性以外必须完全相同，否则直接报错
–去除指针或引用上的const属性
int const volatile x=100;
int const* p=&x;
p =200;//错误
int q=const_cast<int *>§;
*q=200;
>通过去常修改只读变量的值》通过去常修改只读变量的值

重解释类型转换
reinterpret_cast<目标类型>(源类型对象)
–编译器检查源类型和目标类型是否同为指针或引用，或者一个是指针一个是整型，否则直接报错
–在任意类型的指针或引用之间转换，意味着可以将同一个对象视作不同的类型，并以不同的方式访问或处理之
–无论何种类型的指针，从本质上讲都与整数无异，即地址空间中一个特定字节的顺序

目录
返回有效引用
将泛型指针转换为具体指针
通过去常修改预期变量的值
从低地址到高地址打印多字节变量
1返回有效引用
1.1问题
函数返回值通常都具有右值属性，在函数的调用者空间下根据函数的返回类型创建一个匿名对象，负责接收该函数的返回值，该匿名对象一般是临时对象。如果函数返回的是一个引用，那么用作接收该返回值的就不再是一个临时对象，或者一个引用该函数所返回的引用的目标对象的引用，甚至可以是左值引用。

1.2步骤
实现此案例需要按照如下步骤进行。

步骤一：返回变量，静态，成员变量的引用

代码如下所示：

#include < iostream >
int g = 123 ;
struct Dummy {
int m ;
int ＆ foo （ void ） { 返回 g ; }
int ＆ bar （ void ） { static int s = 456 ; 返回 s ; }
int ＆ hum （ void ） { 返回 m ; }
} ;
int main （ int argc ， const char * argv []）
{

虚拟假人=  { 789 } ;
int ＆ rg =虚拟。foo  （）;
std :: cout <<  “ rg =”  << rg << std :: endl ;
int ＆ rs =虚拟。bar  （）;
std :: cout <<  “ rs =”  << rs << std :: endl ;
int ＆ rm =虚拟。哼 （）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

返回 0 ;

}
上述代码中，以下代码：

int ＆ foo  （ void ） {  返回 g ;  }

定义了结构体Dummy的一个成员函数，该函数返回变量变量g的一个引用。

上述代码中，以下代码：

int ＆ rg =虚拟。foo  （）;

定义了一个引用rg，该引用通过返回引用的函数foo替换成为变量的g的别名，所以，附带语句：

std :: cout <<  “ rg =”  << rg << std :: endl ;

输出的是变量变量g的值。

上述代码中，以下代码：

int ＆ bar  （ void ） {  static int s =  456 ;  返回 s ;  }

定义了结构体Dummy的一个成员函数，该函数返回静态局部整型变量s的一个引用。

上述代码中，以下代码：

int ＆ rs =虚拟。bar  （）;

定义了一个引用rs，该引用通过返回引用的函数bar变为静态局部整型变量的别名，所以，附带语句：

std :: cout <<  “ rs =”  << rs << std :: endl ;

输出的是静态局部整型变量s的值。

上述代码中，以下代码：

int ＆ hum  （ void ） {  返回 m ;  }

定义了结构体Dummy的一个成员函数，该函数返回结构体成员变量m的一个引用。

上述代码中，以下代码：

int ＆ rm =虚拟。哼 （）;

定义了一个引用rm，该引用通过返回引用的函数hum将成为机构体成员变量m的别名，所以，包含语句：

std :: cout <<  “ rm =”  << rm << std :: endl ;

输出的是结构体成员变量m的值。

步骤二：返回调用对象本身的引用

代码如下所示：

#include < iostream >
int g = 123 ;
struct Dummy {
int m ;
int ＆ foo （ void ） { 返回 g ; }
int ＆ bar （ void ） { static int s = 456 ; 返回 s ; }
int ＆ hum （ void ） { 返回 m ; }
假人＆ up （ void ） { ++ m ; 返回 * 这个; }
} ;
int main （ int argc ， const char * argv []）
{

虚拟假人=  { 789 } ;
int ＆ rg =虚拟。foo  （）;
std :: cout <<  “ rg =”  << rg << std :: endl ;
int ＆ rs =虚拟。bar  （）;
std :: cout <<  “ rs =”  << rs << std :: endl ;
int ＆ rm =虚拟。哼 （）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

假人。向上（）。向上（）。上（）;
std :: cout <<  “ rm =”  << rm << std :: endl ;
返回 0 ;

}
上述代码中，以下代码：

假人＆ up  （ void ） {  ++ m ;  返回 * 这个;  }

定义了结构体Dummy的一个成员函数，该函数返回结构体自身* this的一个引用。

上述代码中，以下代码：

假人。向上（）。向上（）。上（）;

相当于写成如下方式：

（假人。up （））。向上（）。上（）;

因为dummy.up（）函数的返回值就是dummy本身，所以（dummy.up（））。up（）在第一个up函数返回后等效于（dummy）.up（），依次类推。

步骤三：返回堆变量的引用

代码如下所示：

#include < iostream >
int g = 123 ;
struct Dummy {
int m ;
int ＆ foo （ void ） { 返回 g ; }
int ＆ bar （ void ） { static int s = 456 ; 返回 s ; }
int ＆ hum （ void ） { 返回 m ; }
假人＆ up （ void ） { ++ m ; 返回 * 这个; }
} ;
整数和 平方 （整数x ） {
int * y = 新的 int ；
* y = x * x ;
返回 * y ;
}
int main （ int argc ， const char * argv []）
{

虚拟假人=  { 789 } ;
int ＆ rg =虚拟。foo  （）;
std :: cout <<  “ rg =”  << rg << std :: endl ;
int ＆ rs =虚拟。bar  （）;
std :: cout <<  “ rs =”  << rs << std :: endl ;
int ＆ rm =虚拟。哼 （）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

假人。向上（）。向上（）。上（）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

int ＆ y =  平方（16 ）;
std :: cout << y << std :: endl ;  // 256
删除 ＆ y ;
返回 0 ;

}
上述代码中，以下代码：

整数和 平方 （整数x ） {
int * y = 新的 int ；
* y = x * x ;
返回 * y ;
}
定义了一个返回堆上变量引用的函数，在该函数体中，在堆上申请了一块儿存储空间，并返回该存储空间的引用。

上述代码中，以下代码：

int ＆ y =  平方（16 ）;

定义了一个引用y，该引用是对上申请的一块儿空间的别名。引用y是一种“野引用”或“悬空引用”。

步骤四：返回引用型参数本身

代码如下所示：

#include < iostream >
int g = 123 ;
struct Dummy {
int m ;
int ＆ foo （ void ） { 返回 g ; }
int ＆ bar （ void ） { static int s = 456 ; 返回 s ; }
int ＆ hum （ void ） { 返回 m ; }
假人＆ up （ void ） { ++ m ; 返回 * 这个; }
} ;
整数和 平方 （整数x ） {
int * y = 新的 int ；
* y = x * x ;
返回 * y ;
}
int const ＆ max （ int const ＆ a ， int const ＆ b ）
{
返回 a > b ？a ： b ;
}
int main （ int argc ， const char * argv []）
{

虚拟假人=  { 789 } ;
int ＆ rg =虚拟。foo  （）;
std :: cout <<  “ rg =”  << rg << std :: endl ;
int ＆ rs =虚拟。bar  （）;
std :: cout <<  “ rs =”  << rs << std :: endl ;
int ＆ rm =虚拟。哼 （）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

假人。向上（）。向上（）。上（）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

int ＆ y =  平方（16 ）;
std :: cout << y << std :: endl ;  // 256
删除 ＆ y ;

int a =  123 ， b =  456 ;
std :: cout <<  ＆a <<  ''  <<  ＆ b << std :: endl ;
int const ＆ c =  max  （ a ， b ）;
std :: cout <<  和 c <<  “：”  << c << std :: endl ;
返回 0 ;

}
上述代码中，以下代码：

int const ＆ max （ int const ＆ a ， int const ＆ b ）
{
返回 a > b ？a ： b ;
}
定义了一个返回常引用的函数，该函数有两个常引用形参，返回的是大的那个常引用形参。

上述代码中，以下代码：

int const ＆ c =  max  （ a ， b ）;

定义了一个常引用c，替换为整型变量a或b的别名，至于最终是哪一个变量的别名，而是其中整型变量的值大。在本例中，由于a被初始化变为123 ，b被初始化变成456，b大于a，所以常引用c就是变量b的别名。

步骤五：不能返回局部变量的引用

代码如下所示：

#include < iostream >
int g = 123 ;
struct Dummy {
int m ;
int ＆ foo （ void ） { 返回 g ; }
int ＆ bar （ void ） { static int s = 456 ; 返回 s ; }
int ＆ hum （ void ） { 返回 m ; }
假人＆ up （ void ） { ++ m ; 返回 * 这个; }
} ;
整数和 平方 （整数x ） {
int * y = 新的 int ；
* y = x * x ;
返回 * y ;
}
int const ＆ max （ int const ＆ a ， int const ＆ b ）
{
返回 a > b ？a ： b ;
}
int 和 foo （ void ）
{
int n = 123 ;
返回 n ;
}
int main （ int argc ， const char * argv []）
{

虚拟假人=  { 789 } ;
int ＆ rg =虚拟。foo  （）;
std :: cout <<  “ rg =”  << rg << std :: endl ;
int ＆ rs =虚拟。bar  （）;
std :: cout <<  “ rs =”  << rs << std :: endl ;
int ＆ rm =虚拟。哼 （）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

假人。向上（）。向上（）。上（）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

int ＆ y =  平方（16 ）;
std :: cout << y << std :: endl ;  // 256
删除 ＆ y ;

int a =  123 ， b =  456 ;
std :: cout <<  ＆a <<  ''  <<  ＆ b << std :: endl ;
int const ＆ c =  max  （ a ， b ）;
std :: cout <<  和 c <<  “：”  << c << std :: endl ;

int ＆ z =  foo （）;
std :: cout <<  “ z =”  << z << std :: endl ;

返回 0 ;

}
上述代码中，以下代码：

int 和 foo （ void ）
{
int n = 123 ;
返回 n ;
}
是错误的。因为函数foo返回了局部变量n的引用。由于当函数foo运行结束时，变量n所占的存储空间已经被释放，所以返回的引用就没有一块儿合法的存储空间相对应了，这样必然带来不测的后果。所以下面的代码中：

int ＆ z =  foo （）;

引用z所对应的存储空间是一块儿已经被释放的存储空间，这样使用z将是危险的。

1.3完整代码
本案例的完整代码如下所示：

#include < iostream >
int g = 123 ;
struct Dummy {
int m ;
int ＆ foo （ void ） { 返回 g ; }
int ＆ bar （ void ） { static int s = 456 ; 返回 s ; }
int ＆ hum （ void ） { 返回 m ; }
假人＆ up （ void ） { ++ m ; 返回 * 这个; }
} ;
整数和 平方 （整数x ） {
int * y = 新的 int ；
* y = x * x ;
返回 * y ;
}
int const ＆ max （ int const ＆ a ， int const ＆ b ）
{
返回 a > b ？a ： b ;
}
int 和 foo （ void ）
{
int n = 123 ;
返回 n ;
}
int main （ int argc ， const char * argv []）
{

虚拟假人=  { 789 } ;
int ＆ rg =虚拟。foo  （）;
std :: cout <<  “ rg =”  << rg << std :: endl ;
int ＆ rs =虚拟。bar  （）;
std :: cout <<  “ rs =”  << rs << std :: endl ;
int ＆ rm =虚拟。哼 （）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

假人。向上（）。向上（）。上（）;
std :: cout <<  “ rm =”  << rm << std :: endl ;

int ＆ y =  平方（16 ）;
std :: cout << y << std :: endl ;  // 256
删除 ＆ y ;

int a =  123 ， b =  456 ;
std :: cout <<  ＆a <<  ''  <<  ＆ b << std :: endl ;
int const ＆ c =  max  （ a ， b ）;
std :: cout <<  和 c <<  “：”  << c << std :: endl ;

int ＆ z =  foo （）;
std :: cout <<  “ z =”  << z << std :: endl ;

返回 0 ;

}
2将泛型指针转换为具体指针
2.1问题
static_cast <目标类型>（源类型对象）

编译器对源类型和目标类型做相容性检查，检查不通过报错。

2.2步骤
实现此案例需要按照如下步骤进行。

步骤一：将泛型指针转换为具体指针

代码如下所示：

#include < iostream >
int main （ int argc ， const char * argv []）
{

短x =  10 ;
无效* v =  ＆ x ;
简短* p = static_cast <简短*>  （ v ）;
std :: cout <<  “ x =”  <<  * p << std :: endl ;

短x1 =  10 ， * v1 =  ＆ x1 ;
int * p1 = static_cast < int *>  （ v1 ）; //错误
std :: cout <<  “ x1 =”  <<  * p1 << std :: endl ;

短x2 =  10 ， y2 =  20 ;
无效* v2 =  ＆ y2 ;
int * p2 = static_cast < int *>  （ v2 ）;
* p2 =  0 ;
std :: cout <<  和 x2 <<  “，”  <<  ＆ y2 << std :: endl ;
std :: cout <<  “ x2 =”  << x2 << std :: endl ;
返回 0 ;

}
上述代码中，以下代码：

简短* p = static_cast <简短*>  （ v ）;

源类型（void *）和目标类型（short *）只要在一个方向上可以做隐式类型转换，如，void * v =＆x ;，那么在两个方向上就都可以做静态类型转换。

上述代码中，以下代码：

int * p1 = static_cast < int *>  （ v1 ）;  //错误

源类型（short *）和目标类型（int *）若在两个方向上都不能做隐式类型转换，如，int * p1 = v1 ;，那么在两个方向上也都不能做静态类型转换。

上述代码中，以下代码：

短x2 =  10 ， y2 =  20 ;
无效* v2 =  ＆ y2 ;
int * p2 = static_cast < int *>  （ v2 ）;

虽然没有* v2可以静态类型转换成整型指针p2，但由于v2原来是指向短类型变量的指针，所以静态类型转换语法上没有问题，但会生成运行上的逻辑错误，如以下语句：

* p2 =  0 ;

由于* p2等于一个整型变量，所以将* p2清零会变量4个字节变成零。我们通过观察短整型变量x2和y2的地址，如以下语句：

std :: cout <<  和 x2 <<  “，”  <<  ＆ y2 << std :: endl ;

可以发现短整型变量y2所占的2个字节后面紧接着就是x2所占的2个字节，这样从y2的第一个字节开始清零，连续4个字节，x2也被清零了。可以通过如下语句验证：

std :: cout <<  “ x2 =”  << x2 << std :: endl ;

2.3完整代码
本案例的完整代码如下所示：

#include < iostream >
int main （ int argc ， const char * argv []）
{

短x =  10 ;
无效* v =  ＆ x ;
简短* p = static_cast <简短*>  （ v ）;
std :: cout <<  “ x =”  <<  * p << std :: endl ;

短x1 =  10 ， * v1 =  ＆ x1 ;
int * p1 = static_cast < int *>  （ v1 ）; //错误
std :: cout <<  “ x1 =”  <<  * p1 << std :: endl ;

短x2 =  10 ， y2 =  20 ;
无效* v2 =  ＆ y2 ;
int * p2 = static_cast < int *>  （ v2 ）;
* p2 =  0 ;
std :: cout <<  和 x2 <<  “，”  <<  ＆ y2 << std :: endl ;
std :: cout <<  “ x2 =”  << x2 << std :: endl ;
返回 0 ;

}
3通过去常修改预期变量的值
3.1问题
const_cast <目标类型>（源类型对象）

编译器检查源类型和目标类型是否同为指针或引用，并且其目标类型之间除常属性以外必须完全相同，否则直接报错。

3.2步骤
实现此案例需要按照如下步骤进行。

步骤一：通过去常修改预期变量的值

代码如下所示：

#include < iostream >
int main （ int argc ， const char * argv []）
{

int x =  100 ;
int const * cp =  ＆ x ;
* cp =  200 ； //错误
int * p = const_cast < int *>  （ cp ）;
* p =  200 ；
std :: cout <<  “ x =”  << x << std :: endl ;
std :: cout <<  “ * p =”  <<  * p << std :: endl ;

int x1 =  100 ;
int const ＆ cr = x1 ;
cr =  200 ;  //错误
int ＆ r = const_cast < int ＆>  （ cr ）;
r =  200 ;
std :: cout <<  “ x1 =”  << x1 << std :: endl ;
std :: cout <<  “ r =”  << r << std :: endl ;

返回 0 ;

}
上述代码中，以下代码：

* cp =  200 ； //错误

错误是因为不能通过指针cp修改指针cp所指向的存储单元。

上述代码中，以下代码：

int * p = const_cast < int *>  （ cp ）;

因为源类型（int const *）和目标类型（int *）同为指针，并且除常属性以外必须完全相同，所以可以进行去常类型转换，只是指针p没有了常属性。

上述代码中，以下代码：

cr =  200 ;  //错误

错误是因为cr为常引用，即不能做左值使用。

上述代码中，以下代码：

int ＆ r = const_cast < int ＆>  （ cr ）;

因为源类型（int const＆）和目标类型（int＆）同为引用，并且除常属性以外必须完全相同，所以可以进行去常类型转换，只是引用r没有了常属性。

3.3完整代码
本案例的完整代码如下所示：

#include < iostream >
int main （ int argc ， const char * argv []）
{

int x =  100 ;
int const * cp =  ＆ x ;
* cp =  200 ； //错误
int * p = const_cast < int *>  （ cp ）;
* p =  200 ；
std :: cout <<  “ x =”  << x << std :: endl ;
std :: cout <<  “ * p =”  <<  * p << std :: endl ;

int x1 =  100 ;
int const ＆ cr = x1 ;
cr =  200 ;  //错误
int ＆ r = const_cast < int ＆>  （ cr ）;
r =  200 ;
std :: cout <<  “ x1 =”  << x1 << std :: endl ;
std :: cout <<  “ r =”  << r << std :: endl ;

返回 0 ;

}
4从低地址到高地址打印多字节变量
4.1问题
reinterpret_cast <目标类型>（源类型对象）

编译器检查源类型和目标类型是否同为指针或引用，或者一个是指针一个是整型，否则直接报错。

4.2步骤
实现此案例需要按照如下步骤进行。

步骤一：从低地址到高地址打印多字节变量

代码如下所示：

#include < iostream >
int main （ int argc ， const char * argv []）
{

整数n =  0x12345678 ;
字符* p ;
p = reinterpret_cast < char *>（＆ n ）;
对于 （ int i =  0 ; i <  4 ; i ++， p ++）
    std :: cout << std :: hex <<  （ int ）* p <<  “”“  << std :: endl ;
std :: cout << std :: endl ;

返回 0 ;

}
上述代码中，以下代码：

p = reinterpret_cast < char *>（＆ n ）;

源类型（int *）和目标类型（char *）同为指针，即可进行重解释类型转换。

上述代码中，以下代码：

对于 （ int i =  0 ; i <  4 ; i ++， p ++）
    std :: cout << std :: hex <<  （ int ）* p <<  “”“  << std :: endl ;

因为n为整型变量，整型变量在进行内存操作时一次要处理4个字节。而指针p为字符型指针，则字符变量* p在进行内存操作时一次只处理1个字节，所以要循环4次才能将整型变量n的值全部输出。

对于整型变量n中的值0x12345678在内存中的存放方法是从低地址到高地址存放的，即第一个字节存0x78，第二个字节存0x56，第三个字节存0x34，第四个字节存0x12。指针p指向变量n的第一个字节，这样就可以从低地址到高地址打印整型变量n内的多字节内容了。

4.3完整代码
本案例的完整代码如下所示：

#include < iostream >
int main （ int argc ， const char * argv []）
{

整数n =  0x12345678 ;
字符* p ;
p = reinterpret_cast < char *>（＆ n ）;
对于 （ int i =  0 ; i <  4 ; i ++， p ++）
    std :: cout << std :: hex <<  （ int ）* p <<  “”“  << std :: endl ;
std :: cout << std :: endl ;

返回 0 ;

}

蒙宇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++ linux 获取毫秒_Linux c++获取本地毫秒级精确时间
weixin_36162883的博客
01-26 2661
时间函数介绍Linux c/c++中提供了很多操作时间的库函数，这里简要介绍。使用头文件 #include常用的时间函数包括以下：time原型：time_t time(time_t *t);返回从公元1970年1月1日的UTC时间从0时0分0秒算起到现在所经过的秒数如果t 并非空指针的话，此函数也会将返回值存到t指针所指的内存成功则返回秒数，失败则返回((time_t)-1)值，错误原因存于err...
linux c++程序修改系统时间,Linux C++ 获取和设置系统时间
weixin_39585974的博客
05-01 1679
CSystemTime.h/** CSystemTime.h** Created on: 2014-3-12* Author: qinyinghao* 用于获取和设置系统时间*/#ifndef CSYSTEMTIME_H_#define CSYSTEMTIME_H_extern "C" {#include #include }namespace qyh {typedef struct {in...
C++Linux网络编程Day01
默示MoS的博客
01-25 1032
基本所有的知识点我都写在其中了，有些基础性的东西需要大家自己去学习”计算机网络“的相关知识，至于为什么在使用accept等函数的时候，需要将sockaddr_in转换成sockaddr，这点需要看书：游双的《Linux高性能服务器编程》，在其中的第五章第一节：socket地址API中有详细讨论。。
C++Linux网络编程day02：select模型
默示MoS的博客
02-09 1146
初步认识select模型和进一步认识socket
C++Linux编程基础
默示MoS的博客
01-20 994
C++的Linux网络编程基础知识点
Linux C/C++时间操作
qq_40135848的博客
06-02 637
Linux C/C++时间操作
C++linux高并发服务器项目实践 day1
mcyuuji的博客
03-15 308
实际上，这个宏只是标志着编译器将会吧代码按c还是c++语法来解释如上所述，如果后缀为.c，并且采用gcc编译器，则该宏就是未定义的，否则，就是已定义。
Linux C/C++ 获取系统时间
bluebird_shao的专栏
12-15 5629
C 标准库提供了time()函数与函数可以获取到当前系统的日历时间，但time()函数精度只能到秒级，如果需要更高精度的系统时间需要使用函数，精度达到微秒级。
C++ day5
最新发布
Johan1111的博客
06-11 88
思维导图：
C++ day7
m0_54896893的博客
03-19 251
思维导图：
c++day13
04-25
"C++day13"可能指的是学习C++的第13天，通常在这个阶段，学生会深入理解基础语法，开始接触更高级的概念。描述中的“zuoyezuoyezuoyezuoye”虽然看起来像是重复的练习，但它实际上强调了编程学习的核心——不断实践...
c++day14
04-26
在"C++ Day14"的学习中，我们深入探讨了C++这一强大且广泛使用的编程语言。C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也支持面向对象编程的程序设计语言。C++是在C语言的基础上...
C++基础入门.pdf
04-10
long（长整形）：Windows为4字节，Linux为4字节（32位），8字节（64位），取值范围为-2^31 ~ 2^31-1; long long（长长整形）：占用8字节，取值范围为-2^63 ~ 2^63-1; 本文档提供了C++基础知识的入门指南，包括创建...
mysql-data-clean-timer.zip_linux c++ 数据库_linux mysql_log mysql
09-14
3. 执行`DELETE FROM logs WHERE timestamp () - INTERVAL 7 DAY`这样的SQL语句，删除一周前的记录。这里的`logs`是日志表，`timestamp`是记录时间戳的字段。 4. 关闭数据库连接。 标签中的“log_mysql”提示我们，...
安装Centos7.9&C++&转源到阿里云.doc
10-17
在Linux中，C/C++的开发通常需要安装一些基础工具和库。使用`yum`命令依次安装make、gcc-c++、cmake、bison-devel、ncurses-devel、libaio及其开发库。另外，还需要安装perl-Data-Dumper和net-tools。之后，使用`yum...
QT面试
qq_40632341的博客
01-11 2750
1.事件循环 Qt的主事件循环能够从事件队列中获取本地窗口系统事件，然后判断事件类型，并将事件分发给特定的接收对象。 主事件循环通过调用QCoreApplication::exec()启动，随着QCoreApplication::exit()结束，本地的事件循环可用利用QEventLoop构建。 2.多线程 继承QThread方法 1.定义继承QThread的类A 重写run()函数; 2.在主线...
linux C++ day1
qq_40632341的博客
02-10 273
linux C++ day1 编译器 -g++ -gcc -lstdc++ 扩展名 -.cpp/.cc/.C/.cxx -.c -x C++ 头文件 –#include -#include I/O流 –cout<< –cin>> –也可以用scanf/printf 名字空间 –std:: –using namespace std; –所有标准类型、对象和函数都位于std命名...
Linux C++ day2
qq_40632341的博客
02-11 192
重载与缺省参数==》重载{重载与重载缺省 C++换名 extern"C"}缺省参数 重载与重载解析 同一作用域中，函数名相同，参数表不同的函数，构成重载关系 –void foo(void); void foo(int n); void foo(int* p); char const* foo(int n,double d); char const* foo(double d,int n); 重载与...
linux C++ day06
qq_40632341的博客
02-13 170
目录： 支持结息调息功能的银行账户类 饿汉式的单例模式 懒汉式的单例模式 考虑线程安全的单例模式 通过成员指针访问对象 1 支持结息调息功能的银行账户类 1.1 问题 静态成员变量不包含在对象实例中，具有进程级的生命周期。静态成员函数没有this指针，也没有常属性。但是静态成员受类作用域和访问控制限定符的约束。静态成员变量的声明在类中；而定义和初始化，只能在类的外部而不能在构造函数中进行。静态成员...
linux c++ std::atomic
08-15
- *1* *2* *3* [linux c/c++ 原子操作库 atomic atomic_flag 简介](https://blog.csdn.net/whatday/article/details/122298078)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值