linux C++ day3

最新推荐文章于 2024-06-02 15:23:06 发布
最新推荐文章于 2024-06-02 15:23:06 发布
阅读量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
    评论
专栏目录
linux C++ day06
qq_40632341的博客
02-13 166
目录： 支持结息调息功能的银行账户类 饿汉式的单例模式 懒汉式的单例模式 考虑线程安全的单例模式 通过成员指针访问对象 1 支持结息调息功能的银行账户类 1.1 问题 静态成员变量不包含在对象实例中，具有进程级的生命周期。静态成员函数没有this指针，也没有常属性。但是静态成员受类作用域和访问控制限定符的约束。静态成员变量的声明在类中；而定义和初始化，只能在类的外部而不能在构造函数中进行。静态成员...
linux c++编程
manongxianfeng的博客
03-29 5164
这本阿里P8撰写的算法笔记，再次推荐给大家，身边不少朋友学完这本书最后加入大厂： Github 疯传！史上最强悍！阿里大佬「LeetCode刷题手册」开放下载了！ 一、前提 以下环境均采用VMWare虚拟机安装CentOS6.6环境下编程。 想要在Linux上进行编辑，必须学会Linux基本编辑命令和其他基本命令 学习路径：Linux系统基础一 有编程基础。 二、安装编译器，并开始第一程序 1.安装编译器gcc & g++ yum install gcc //安装gcc yum install
C++Linux编程基础
默示MoS的博客
01-20 985
C++的Linux网络编程基础知识点
C++Linux网络编程day02：select模型
默示MoS的博客
02-09 1125
初步认识select模型和进一步认识socket
Linux C/C++时间操作
最新发布
qq_40135848的博客
06-02 595
Linux C/C++时间操作
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 2729
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 185
重载与缺省参数==》重载{重载与重载缺省 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++ day10
qq_40632341的博客
02-14 151
目录： 智能手机 钻石继承 虚继承对钻石继承的改善 阻断继承类的静态实例化 电子文档阅读器 1 智能手机 1.1 问题 一个类可以同时从多个基类继承实现代码。如果在子类的多个基类中，存在同名的标识符，而且子类又没有隐藏该名字，那么任何试图在子类中，或通过子类对象访问该名字的操作，都将引发歧义，除非通过作用域限定操作符“::”显式指明所属基类。如果无法避免基类中的名字冲突，最简单的方法是在子类中隐藏...
linux C++ day4
qq_40632341的博客
02-13 150
目录 定义用户类并实例化为对象 将用户类的声明、实现和使用分别放在三个不同文件里 类的构造函数可以重载 带缺省参数的构造函数 缺省的构造函数 编译器提供的缺省构造函数 编译器不提供缺省构造函数 数组元素类的缺省构造函数 子对象类的缺省构造函数 父对象类的缺省构造函数 支持自定义类型转换的构造函数 拷贝构造函数 编译器提供的缺省拷贝构造函数 用自定义拷贝构造函数取代缺省拷贝构造函数 缺省拷贝构造函数...
Linux c++ day09
qq_40632341的博客
02-14 147
目录： 智能手机 钻石继承 虚继承对钻石继承的改善 阻断继承类的静态实例化 电子文档阅读器 1 智能手机 1.1 问题 一个类可以同时从多个基类继承实现代码。如果在子类的多个基类中，存在同名的标识符，而且子类又没有隐藏该名字，那么任何试图在子类中，或通过子类对象访问该名字的操作，都将引发歧义，除非通过作用域限定操作符“::”显式指明所属基类。如果无法避免基类中的名字冲突，最简单的方法是在子类中隐藏...
linux C++ day5
qq_40632341的博客
02-13 110
目录： 带初始化表的构造函数 数组和结构型成员的初始化 类类型成员的初始化 常量和引用型成员的初始化 初始化顺序 隐藏的this指针参数 通过this指针区分成员 返回调用对象 教师和学生 常函数和mutable关键字 通过常/非常对象调用常/非常函数 常函数与非常函数的重载匹配 析构函数的基本用法 析构函数负责总善后 缺省析构函数不释放动态分配的资源 缺省拷贝构造函数仅支持浅拷贝 自定义拷贝构造...
LInux C++ day08
qq_40632341的博客
02-14 106
目录： 人、学生和教师 公有成员、保护成员和私有成员 公有继承、保护继承和私有继承 基类子对象的隐式构造 基类子对象的显式构造 子类对象的构造过程 断子绝孙的类 delete指向子类对象的基类指针 子类对象的析构过程 缺省全拷贝 自定义局部拷贝 自定义全拷贝 缺省全赋值 自定义局部赋值 自定义全赋值 1 人、学生和教师 1.1 问题 定义三个类，它们是类Human，类Student和类Teache...
linux下C++动态链接C++库示例详解.pdf
07-14
该资源是一份关于在Linux环境下使用C++进行动态链接C++库的详细教程。文档中提到了动态链接库在C++中的应用，特别是如何处理C++特有的name mangling问题，以及如何利用dlopen API来解决C++类的加载问题。 在Linux...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值