【C++】基础第一节C++与C的区别

于 2019-02-15 19:32:10 发布
阅读量215 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hujiaqi2018/article/details/87358004
版权

一：QT软件简单使用

安装目录尽量不要有中文，新建工程也是。

第一个是运行，第二个是调试。在项目文件目录中有debug文件夹中有工程文件。

注意：新建工程时，选择non_QT project，选择c或者C++应用。

在源文件上面打开代码：

TEMPLATE = app
CONFIG += console//删除这行代码运行，之后撤销恢复这行代码就可以弹出运行显示窗口
CONFIG -= app_bundle
CONFIG -= qt

SOURCES += main.c

 参考或调试别人程序时，需要把工程目录中pro.user后缀文件删除编译器自动生成。

二：C与C++基本区别

C++适合开发软件c语言适合开发系统。

c++ 面向对象 C语言面向过程

c++比c效率差10%

三：命名空间使用方式

因为单词数太少，不同的人写的程序不可能所有的变量都没有重名现象，对于库来说，这个问题尤其严重，为了解决这个问题，引入了名字空间这个概念，通过使用 namespace xxx；你所使用的库函数或变量就是在该名字空间中定义的，这样一来就不会引起不必要的冲突了。

#include <stdio.h>
//
namespace Name1//使用namespace定义一个命名空间
{
 struct Student//里面结构体 变量a，b和add函数，嵌套的命名空间Name3都是命名空间Name1的成员
 {
 };
 int a;
 int add(int a, int b)
 {
 return a+b;//注意有返回值
 }
 namespace Name3
{
 int a;//注意这个a和外面Name1的a不同，引用的时候要先进入Name1在进入Name3才可以用这个a
 }
}
namespace Name2
{
 int a;
}
//
// 1 用命名空间名+域解析符 ::引用成员
int main1()
{
 Name1::a = 10;
 Name1::Name3::a = 2;//嵌套引用
 printf ("%d\n", Name1::add(Name1::Name3::a,5));//引用add函数要打开命名空间Name1
 return 0;
}

//使用using声明一个命名空间
//using只对当前作用域有效离开这个函数还是需要用Name1::
int main2()
{

    using namespace Name1;//声明后的空间 a前面不需要加Name1：：
     a=10;
     Name3::a=2;//由于Name3嵌套在Name1中，使用3中的a还是要Name3

      printf("%d\n",add(Name3::a,5));

 return 0;

}//注意不要同时声明有相同成员的命名空间，使用时候会不假前缀会冲突
int a;使用默认命名空间
int main()
{
   using namespace Name1;
   Name1::a=10;
    ::a=2;当声明一个全局变量时，为了防止与其他命名空间冲突，可以使用：：a默认命名空间
    printf("%d\n",add(::a,5));
 


}

命名空间内部成员不一定写在一个函数‘里。8

可以

namespace name1（）

{

  int a;

 

 

} 

三C++中的输入输出

C++专属头文件

#include <iostream>//i代表输入 o代表输出 stream代表流

c语言中 xxx.b->cxxx.b

              stdio.h——》Cstdio.h

             string.h——》Cstring.h

C ++中加c的拥有命名空间std

cout标准输出

cout是变量对应c中printf函数，与<<左移预算法结合成一个从右网住流动的数据流。

右边是字符串，左边是标准输出cout

std::endl换行

c中的转义字符在C++中同样可以使用。

std::cout << "hello world" << std::endl;
 std::cout << "hello world\n";

using namespace std;//这样可以不用加std：：前缀

int a = 10;
 char c = 'A';
 double d = 1.2;
 const char *str = "hello";
 cout << "a = " << a << ", c = " << c << ", d = " << d << ",
str = " << str << endl;
 printf ("a = %d, c = %c, d = %.1f, str = %s\n", a, c, d, str);

;cout可以识别不同类型的数据类型的变量，不需要像printf写%d等

 

标准输入：cin scanf

int main()
{
 int a;
char c;
double d;
char str[10];
 scanf ("%d, %c, %lf, %s", &a, &c, &d, str);//在输入端要用逗号隔开才不会出错
 // >> cin从右往左 输出，同样自动识别数据类型
 // cin >> a >> c >> d >> str;
 printf ("a = %d, c = %c, d = %.1f, str = %s\n", a, c, d, str);

 // cin cout 都是放在最左边
 // a << cin;
 // hello >> cout;
 return 0;
}

寄存器变量：

#include <iostream>
using namespace std;
//
int main1()
{
for (int i = 0; i < 10; i++)
cout << i << endl;//简单循环函数
return 0;
}
//
int main2()在c中不允许对寄存器变量使用取地址&，C++可以取地址，但取地址后不在寄存器变量
{
// a
register int a = 10;寄存器变量
// C++中对寄存器进行&操作，变量将放入内存中

printf("&a = %p\n", &a);
return 0;

 

新的数据类型bool,值为ture（非0不一定只有1） 和false（0） 

int main4()
{

    bool b=false;//b=0
     std::cout<<b<<std::endl;
    b=b-1;//-1显示为1
     std::cout<<b<<std::endl;
      b=b+1;//2显示为2
     std::cout<<b<<std::endl;

}
int main()
{
bool b = false;
// if (b == true) //
if (b)
{
}
demo3.cpp 2
// if ( b == false) //
if (!b)
{
}

注意：不可将浮点变量用“==”或“！=”与任何数字比较。要留意，无论是float 还是double 类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。

float f = 0.0000000000000000000000001;
if (f < 0.000001 && f > -0.000001)
cout << "0" << endl;
else
cout << "!0" << endl;
float f1,f2;
if (f1 == f2)
{
}
if (f1 - f2 < 0.000001 && f1 - f2 > -0.000001)
{
cout << "f1 == f2" << endl;
}
return 0;
}

三目运算符

#include <iostream>

using namespace std;

int main1()
{
    int a = 10;
    int b = 20;
    int c = a>b ? a : b;//在C中3目运算符不可以当左值的

    cout << c << endl;

    // C++中三目运算符返回的是空间
    a>b ? a : b = 123;  // *(a > b ? &a : &b) = 123;
    printf ("a = %d, b = %d\n", a, b);//这里如果写成a<b则不会执行=123语句，因为程序从左边开始


    // 如果做左值使用，则返回值中不能存在常量
    // a>b ? 10 : b = 123;
    return 0;
}



// 函数的默认参数； 函数的形参可以设置默认值
int add(int a, int b = 10)
{
    return a+b;
}

// 注意:
// 1、如果函数的某个形参使用了默认参数，则其右边的所有参数都要有默认参数（常数）
int func(int a, int b = 10, int c = 20)
{

}

// 2、函数的默认参数在函数声明和函数定义中只能有一个进行设置
int func1(int a, int b = 10);  // 函数声明
int func1(int a, int b)//这边不能在对B赋值
{
    cout << b << endl;
}

int main()
{
    cout << add(1,2) << endl;
    cout << add(1) << endl;

   

    return 0;
}

函数的占位

 

#include <iostream>

using namespace std;

// 函数的占位参数:只有类型，没有变量名的参数
int func(int a, int)
{

}

// 占位参数可以和默认参数一起使用
int func1(int a, int = 0)
{

}

int main()
{
    func(1,2);//2不起作用但编译可以通过

    func1(1);//只需要输入一个参数就行

    return 0;
}

函数重载：

 

#include <iostream>

using namespace std;

// 函数重载：允许写同名函数

void pitnt(int a)
{
    printf ("%d\n", a);
}

void pitnt(int a, int b)
{
    printf ("a = %d, b = %d\n", a, b);
}

void pitnt(int a, char c)
{
    printf ("a =  %d, c = %c\n", a, c);
}

// 重载的条件（任意一个）：
// 1、参数的个数不同
// 2、参数的类型不同

// 注意：
// 1、函数的返回值不能作为重载的条件
// 2、函数指向重载函数，要严格的匹配函数指针的类型

// 函数指针 类型
typedef void (*PFUNC)(int, int);返回值类型 ( * 指针变量名) ([形参列表]);

int main()
{
    pitnt(1, 2);//对应第二个
    pitnt(1);//对应第一个
    pitnt(1,'A');//对应第三个

    PFUNC f = pitnt;//将pitnt入口地址给函数指针f
    f(1,2);
    //f(1);
    //f(1, 'A');划掉的2个是不可以的因为函数指针类型的型参必须有2个int类型数据

    return 0;
}

C++语言中const与C的区别

#include <iostream>

using namespace std;


void func()
{
#define SIZE 10//注意define宏定义后影响后面的所有程序，define前面的则不受影响

    const int size = 10;


    int a[size];
//#undef SIZE
}

// C++ const 修饰的内容 是一个常量不可以改变也不可以用指针
int main()
{
    const int a = 10;

    // 当对const 常量进行取地址的时候，编译会为其分配空间
    // 但是const常量并不用
    int *pa = (int*)&a;
    *pa = 30;

    printf ("pa = %p, &a = %p\n", pa, &a);//在c语言中a的值会改变的30，所以c语言const不是很安全，这里他们地址是一样的

    // 在使用const常量的时候，是从符号表中取值，而不是内存中取值
    printf ("*pa = %d, a = %d\n", *pa, a);

    //cout << SIZE << endl;

    //cout << size << endl;



    return 0;
}

 

C++变量的引用

  int a = 10; 
  int &b = a;  
   b = 20;
 cout << a << endl;
 类型 &别名 = 空间（变量名） 
 b  和  a 代表的是同一块空间，引用是给空间取个别名，本质上是一个常量指针   
 引用必须要进行初始化，引用目的是替代C语言中容易出现段错误的指针。
表达式中的取地址符&不再是取变量的地址，而是用来表示该变量是引用类型的变量。
在回调函数中可以这样使用：引用和指针一样都是在32位系统中4个字节

//int mySwap(int a, int b)
//{
//    int tmp = a;
//    a = b;
//    b = tmp;
//}
 注意：函数调用结束时，形参的空间和指针将会释放

int mySwap(int *pa, int *pb)//使用指针
{
    int tmp = *pa;
    *pa = *pb;
    *pb = tmp;//这边不是改变指针的指向而且替换指向的内容
}

int mySwap(int &ra, int &rb)//使用引用给a和b所对应的空间取个别名
{
    int tmp = ra;
    ra = rb;
    rb = tmp;
}

int main2()
{
    int a = 10;
    int b = 20;

    mySwap(a, b);这边对应使用引用替换函数
    printf ("a = %d, b = %d\n", a, b);

    mySwap(&a, &b);这边对应使用指针的替换函数
    printf ("a = %d, b = %d\n", a, b);
  
    return 0;
}

 

 结构体引用 ：  

#include <iostream>

using namespace std;

struct Student
{
    int id;
    const char *name;
};


//void print(Student *ps)
//{
  //  printf ("id = %d, name = %s\n", ps->id, ps->name);//用指针调用id name
//}

void print(Student &s)
{
    printf ("id = %d, name = %s\n", s.id, s.name);//用引用调用id name
}


void func1(Student **ps)//这边直接写* ps会出现段错误
{
    *ps = (Student *)malloc(sizeof(Student)/sizeof(char));
    (*ps)->id   = 2;
    (*ps)->name = "小红";

}

void func1(Student* &ps)//这边ps给psl对应空间取了个别名
{
    ps = (Student *)malloc(sizeof(Student)/sizeof(char));
    ps->id   = 2;
    ps->name = "小红";

}


int main()
{
    Student s = {1, "夏明"};
    //printf ("id = %d, name = %s\n", s.id, s.name);
    print(s);
    print(&s);

    Student *ps1 = NULL;
    // func1(&ps1);
    func1(ps1);//引用
    printf ("id = %d, name = %s\n", ps1->id, ps1->name);

    return 0;
}
引用的返回值：
#include <iostream>

using namespace std;

struct Test
{
    double &c1;
    double &c2;
};

// 引用的本质 是一个  常指针
// int &ra   ===>   int * const pa;
int main1()
{
    int a  = 10;
    int &b = a;   // int *const pb = &a;

    b = 20;       // *pb = 20  &b  ===  &*pb  ===  &a;

    return 0;
}


// 引用作为函数的返回值: 不能返回局部变量的引用
// 可以返回  静态变量 全局变量的引用
int &func()
{
    static int a = 0;

    printf ("a = %d\n", a);
    return a;
}

int main2()
{
    // 1、不接收返回值
    func();
    cout <<"---------------------------" <<endl;

    // 2、用普通变量去接收引用， 接收回来的是 值， 不是空间
    int b = func();
    cout << "b = " << b << endl;
    b = 100;
    func();

    cout <<"---------------------------" <<endl;
    // 3、用引用接收返回值，接回来的是空间
    int &c = func();
    c = 100;
    func();

    cout <<"---------------------------" <<endl;
    // 4、函数返回引用，可以作为左值使用
    func() = 200;
    func();


    return 0;
}

int add(const int &ra, const int &rb)
{
    return ra + rb;
}

int add(const int &ra, const int &rb)
{

    return ra + rb;
}

int a = 10;
int main()
{

    int b = 20;
    int &c=b;
    b=12;
    cout<<b<<endl;
    cout << add(a, b) << endl;
    cout << add(1, 2) << endl;

    // 常量引用
    // 1、引用变量  ： 不能通过引用改变变量的值
    // 2、引用常量
    // 引用常量的时候，编译器会为常量分配空间
    // 引用的是新分配的空间
    const int &rc = 10;
    int *pc = (int*)&rc;
    *pc = 20;
    cout << rc << endl;


    return 0;
}

函数做左值，返回值必定是引用

#include <iostream>

using namespace std;

// 宏  宏常量  宏函数
// 建议用 const   替换宏常量
// 建议用 内联函数 替换宏函数
// 内联函数

// 定义： 在函数定义前加 inline 关键字， 在声明前加无效
inline int add(int a, int b)
{
    return a+b;
}

#define  ADD(a,b)  a+b//在c语言中要加括号

// 注意：
// 1、内联是一种请求，不一定通过
// 2、函数不要太长，5行以内
// 3、内联函数不要有循环语句和复杂的条件判断语句
// 4、内联成功，编译完以后，函数在可执行程序中是不存在的，不能对内联函数进行取地址操作，不能作为回调函数使用
int main()
{
    cout << ADD(10, 20)*ADD(3,4) << endl;
    cout << add(10, 20)*add(3,4) << endl;

    return 0;
}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值