namespace的使用
#include <iostream>
using namespace std;
//定义命名空间
namespace NameSpaceA
{
int a = 0;
}
namespace NameSpaceB
{
int a=1;
namespace NameSpaceC
{
struct Teacher
{
/* data */
char name[10];
int age;
};
}
}
int main()
{
//using namespace NameSpaceA;
using NameSpaceB::NameSpaceC::Teacher;
using namespace NameSpaceB;
printf("a = %d \n",a);
printf("a = %d \n",NameSpaceA::a);
Teacher t1;
t1.age = 20;
printf("age: %d \n",t1.age);
return 0;
}
const使用：
//C++编译器对const常量的处理
//当看见常量声明时,会在符号表中放入常量-->当要使用时，直接取符号表中的值替换
//C中的const变量是个只读变量,但自己的存储空间
//C++中-->const为全局或&时才会分配空间
//#define和const相同之处：C++中的const修饰,是一个真正的常量，而C中只是个只读变量。const修饰的常量在编译期间就确定了。
//#define与const不同之处：#define-->由预处理器处理,单纯的文本替换
// const---->编译器处理,提供类型检查和作用域检查
#include <iostream>
using namespace std;
void fun1()
{
#define a 10
const int b = 20;
}
void fun2()
{
printf("%d\n",a);
//cout<<b<<endl;
}
int main()
{
//int &a = 20;
const int &b = 30; //直接取符号表中的值代替,当使用&或者extern时会给常量分配内存空间
fun1();
fun2();
getchar();
return 0;
}
引用
//引用的本质：
// 1 引用在C++内部实现是一个常指针 Type &name --> Type * const name
// 2 C++编译器在编译过程中使用常指针作为引用的内部实现.因此所占用的空间与指针一样大 4
// 3 C++为引用的使用做了细节隐藏
/*
函数返回值是引用：
1 难点注意：要观察返回的变量是在哪里分配内存空间的--->如果是临时变量，即在栈上分配内存,函数返回时会被析构(释放)
--> 不能作为左值使用，因为空间被释放了。没地方存了
--> 不能成为其它引用的初始值,空间被释放了
2 c++链式编程编程、操作符重载
*/
/*
指针的引用-->只不过是为存储指针的这块内存取了个别名而已
*/
#include <iostream>
using namespace std;
//证明引用有自己的内存空间
struct Teacher
{
/* data */
int &a;
int &b;
};
int main2()
{
printf("sizeof(Teacher):%d \n",sizeof(Teacher)); //8-->int const *a and int const *b
return 0;
}
int main1()
{
int a = 10;
int &b = a;
printf("&a:%d\n",&a);
printf("&b:%d\n",&b);
//对同一内存空间可以取好几个名字吗？ --> 不行
//实际上：int const *b = &a &b:编译器会帮我们做 *(&b)
return 0;
}
//引用做函数返回值
int f1()
{
int a;
a = 10;
return a;
}
int &f2()
{
int a;
a = 20;
return a;
}
int *f3()
{
int a;
a = 30;
return &a;
}
//---> 害，其实就一句话,看内存有没有被释放而已
//static + &引用
int j() //-->返回的只是一个数值而已
{
static int a = 10;
a++;
printf("a:%d \n",a);
return a;
}
int &j2() //返回 *(&a)
{
static int a = 20;
a++;
printf("a:%d \n",a);
return a;
}
int *j3() //->返回的是一个地址
{
static int a = 30;
a++;
printf("a:%d \n",a);
return &a;
}
int main33()
{
//j()-->返回的是一个数值,不能当左值 11 = 100(err)
j2() = 100;
j2();
//手工打造引用条件
*(j3()) = 100;
j3();
getchar();
return 0;
}
//非基础类型：可能设计到深拷贝和浅拷贝的问题-->其实也就是有没有内存空间的问题
struct Student
{
int age;
};
Student & Op(Student &s)
{
/* data */
s.age = 30;
}
int main44()
{
Student s1;
s1.age = 20;
Op(s1);
cout<<s1.age;
return 0;
}
//常引用-->const难点
int main55()
{
int a = 10;
const int &b = a; //const char const* b = xxxx ---> 但a可以改变
// b = 11;
a = 20;
int *p = (int *)&b;
//
const int aa = 20;
const int &bb = aa;
//int &b = aa;
}
//const:常量 pk 变量 -->const int *const p
int main()
{
const int b =10;
printf("&b:%d \n",&b);
const int &bb = 19;
printf("&bb:%d \n",&bb);
getchar();
return 0;
}
三目运算
//在C++中，三目运算返回变量本身，可以做左值
#include <iostream>
using namespace std;
int main()
{
int a = 20;
int b = 30;
a = (a<b?a:b) = 30;
cout<<a<<endl;
getchar();
return 0;
}
函数相关
#include <iostream>
using namespace std;
/*
第一部分：inline函数
1.内联函数声明时inline关键字必须和函数定义结合在一起,否则编译器会直接忽略请求
2.内联函数是一种特殊的函数,具有普通函数的特征(参数检查，返回类型等)
-->相对于普通的函数而言,内联函数省去了压栈、跳转、返回的开销
3.内联函数由编译器处理,然后将编译后的函数体直接插入调用的地方
宏定义-->预处理器处理,进行简单的文本替换,没有任何编译过程
*/
#define MYFUNC(a,b) ((a)<(b)?(a):(b)) //预处理阶段,简单的文本替换
inline int func(int a , int b) //经历编译过程
{
return a<b?a:b;
}
int main01()
{
int a = 1;
int b = 3;
int c =func(++a,b);
cout<<c; //2
int d = MYFUNC(++a,b);
cout<<d<<" "; //3
getchar();
return 0;
}
/*
第二部分：函数的占位参数：
占位参数只有参数类型声明,而没有参数名声明
一般情况下,函数内部无法使用占位参数
*/
int f(int a , int b , int)
{
return a+b;
}
int main02()
{
// int c = f(1,2);
//cout<<c<<" ";
int d = f(1,2,3);
cout<<d;
getchar();
return 0;
}
//默认参数和占位参数一起使用-->可以方便程序的扩展
int f2(int a,int b,int = 0)
{
return a+b;
}
int main022()
{
f2(1,2);
f2(1,2,3);
getchar();
return 0;
}
/*
第三部分:
函数重载-->参数个数不同 、 参数类型不同 、 参数顺序不同
编译器调用重载函数的准则：
将所有同名函数作为候选者
尝试寻找可行的候选者
精确匹配实参
匹配失败：
找到的可行函数不唯一,出现二义性,编译失败
没有找到可行的函数
注意事项：
重载函数在本质上是不同的函数,是相互独立的(静态链编)
函数重载是发生在同一个类里面的
*/
//函数重载遇上函数指针
int g(int x)
{
return x;
}
int g(int a ,int b)
{
return a+b;
}
typedef int(*PFUNC)(int);
int main()
{
int c = 0;
PFUNC p = g;
c = p(1);
cout<<c<<endl;
getchar();
return 0;
}
//register-->暗示编译程序相应的变量将被频繁的使用,如果可能的话,应该将其放到CPU的寄存器中,加快访问速度
//减少了去内存中寻址、取值
// #ifdef NOSTRUTASSIGN
// memcpy (d , s , l)
// {
// register char *d;
// register char *s;
// register int l;
// while (l--)
// {
// *d++ = *s++;
// }
// }
// #endif
|