C++中需要注意的细节你知道吗

目录
  • namespace的使用
  • const使用:
  • 引用
  • 三目运算
  • 函数相关
  • 总结

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

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • C++ main函数的几点细节

    1.main()函数的标准原型 main函数是C++程序的入口函数,C++标准规定main()函数的返回值类型为int,返回值用于表示程序的退出状态,如果返回0则表示程序正常退出,如果返回非0,则表示出现异常.C++标准规定,main()函数原型有两种: int main(); int main(int argc,char* argv[]); //或 int main(int argc,char** argv); 当main()函数的返回值为int,而函数内没有出现return语句时,同样可以通

  • C++函数返回值为对象时,构造析构函数的执行细节

    看如下代码: 复制代码 代码如下: #include<iostream>class TestConstructor{public:    TestConstructor()    {        std::cout<<"TestConstructor()"<<std::endl;    }    ~TestConstructor()    {        std::cout<<"~TestConstructor()"

  • C++实现二分法的一些细节(常用场景)

    二分法是在一个排好序的序列(数组,链表等)中,不断收缩区间来进行目标值查找的一种算法,下面我们就来探究二分法使用的一些细节,以及常用的场景: 寻找一个数:寻找左侧边界:寻找右侧边界. 一.二分法的通用框架 int binarySearch(vector<int>& nums, int target){ int left=0, right=nums.size(); while(left < right) { int mid=(left+right)/2; if(nums[mid]

  • C++中const的实现细节介绍(C,C#同理)

    1.什么是const?  常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的.(当然,我们可以偷梁换柱进行更新:) 2.为什么引入const?  const 推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点. 3.cons有什么主要的作用? (1)可以定义const常量,具有不可变性. 例如:  const int Max=100; int Array[Max]; (2)便于进行类型检查,使编译器对处理内容有更多了解,消除了一些隐患.例如:

  • C++中putchar与getchar函数的细节及运用

    在C语言中,输入和输出除了用printf和scanf外,另外还有用于输入字符的函数为getchar()函数,用于输出字符的函数为putchar()函数. 功能解释如下: 下面用例子来说明函数的用法 #include <stdio.h> int main() { int ch = 0; while ((ch = getchar()) != EOF) putchar(ch); return 0; } 结果: 可以看出,当按下键盘上的回车键时,getchar函数会读取到屏幕中输入的字符和回车字符'\

  • 在Swift中使用KVO的细节以及内部实现解析(推荐)

    KVO是什么? KVO 是 Objective-C 对观察者设计模式的一种实现.[另外一种是:通知机制(notification),详情参考:iOS 趣谈设计模式--通知]: KVO提供一种机制,指定一个被观察对象(例如A类),当对象某个属性(例如A中的字符串name)发生更改时,对象会获得通知,并作出相应处理:[且不需要给被观察的对象添加任何额外代码,就能使用KVO机制] 在MVC设计架构下的项目,KVO机制很适合实现mode模型和view视图之间的通讯. 例如:代码中,在模型类A创建属性数据

  • 程序员都不知道C语言中的这些小细节

    既然题目都说了是小细节,一来就介绍细节多没意思啊,先坑坑大家再详细介绍吧,嘿嘿.直接上7个题吧,看看你能做对几个呢? 计算型细节 ①: #include <stdio.h> int main() { char a = 3; char b = 127; char c = a + b; printf("结果是:%d",c); return 0; } 您想想这个题的答案是多少?先不要看后面的答案哦 答案是 -126, 嘿嘿,是不是答错了呢?先不要着急,继续看下面的题 ②: #in

  • Java中泛型学习之细节篇

    目录 简介 正文 什么是类型参数 为啥要有泛型 泛型的演变史 类型擦除 泛型的应用场景 通配符限定 动态类型安全检查 总结 简介 泛型的作用就是把类型参数化,也就是我们常说的类型参数 平时我们接触的普通方法的参数,比如public void fun(String s):参数的类型是String,是固定的 现在泛型的作用就是再将String定义为可变的参数,即定义一个类型参数T,比如public static <T> void fun(T t);这时参数的类型就是T的类型,是不固定的 从上面的S

  • Java各种锁在工作中使用场景和细节经验总结

    目录 1.synchronized 1.1.共享资源初始化 2.CountDownLatch 2.1.场景 2.2.实现 3.总结 1.synchronized synchronized 是可重入的排它锁,和 ReentrantLock 锁功能相似,任何使用 synchronized 的地方,几乎都可以使用 ReentrantLock 来代替,两者最大的相似点就是:可重入 + 排它锁,两者的区别主要有这些: ReentrantLock 的功能更加丰富,比如提供了 Condition,可以打断的加

  • Go中函数的使用细节与注意事项详解

    目录 细节汇总 值传递和指针传递 什么是重载 函数类型的变量 函数作为形参传入 自定义数据类型 返回值命名 可变参数 总结练习 细节汇总 函数的形参列表可以是多个,返回值列表也可以是多个 形参列表和返回值列表的数据类型,可以是值类型.也可以是引用类型 函数的命名遵循标识符命名规范,首字母不能是数字,首字母大写表示该函数可以被本包文件和其它文件使用,类似public:首字母小写只能被本包文件使用,类似private. 函数中的变量是局部的,外部不能访问.作用域 基本数据类型和数组都是值传递的,即进

  • 浅析Go语言中数组的这些细节

    目录 Go语言基础二 len&cap 二维数组的遍历 数组的拷贝与传参 求数组所有元素之和 例题:数组元素匹配问题 今日总结 Go语言基础二 len&cap 书接上文,我们提到二维数组中的第二个维度的数组不能用...来表示,接下来我们要认识两个新的函数,它们分别是len和cap package main ​ func main() { a := [2]int{} println(len(a), cap(a)) } 由上方代码可知,我们在main函数里面定义了一个a数组,长度为2,未进行初始

  • 详解lodash中的cloneDeep使用细节

    目录 正文 支持的数据类型 cloneDeepWith 拷贝算法介绍 structuredClone VS cloneDeep 循环引用处理方法 总结 正文 lodash中的cloneDeep是一个使用频率比较高的方法,然而你真的理解其中的细节处理吗?如果下面几个问题你还有疑惑那么本文对你或多或少有些帮助. cloneDeep中支持拷贝函数.Error对象.DOM节点以及WeakMap对象吗? cloneDeep中使用了哪种算法呢? 浏览器中提供的实现深拷贝的方式除了JSON.parse(JSO

  • SQLite中的B-Tree实现细节分析

    SQLite在存储在外部的数据库是以B-Tree来组织的.关于B-tree的细节,参考 ** ** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: ** "Sorting And Searching", pages 473-480. Addison-Wesley ** Publishing Company, Reading, Massachusetts. ** 基本思想是文件包含的每一页都包括N个数据库入口和N+1

  • 不错的JS中变量相关的细节分析

    这里讨论一下我对Javascript中变量相关细节的认识,有不当之处欢迎来批. 一.变量的类型 Javascript和Java.C这些语言不同,它是一种无类型.弱检测的语言.它对变量的定义并不需要声明变量类型,我们只要通过赋值的形式,可以将各种类型的数据赋值给同一个变量.例如: i=100;//Number类型 i="variable";//String类型 i={x:4};//Object类型 i=[1,2,3];//Array类型 JS的这种特性虽然让我们的编码更加灵活,但也带来了

  • C++中需要注意的细节你知道吗

    目录 namespace的使用 const使用: 引用 三目运算 函数相关 总结 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; };

随机推荐