C++学习(一)

C++和C的常量区别

//C的常量是伪常量，C++的常量是真常量
//const修饰的是指不可变的常量
//在C中：
int main(){
    const int number = 100;
    int * numP = &number;
    *nump = 10000;7
    //此时 number已被改为10000
    return 0;
}
在c++中可以运行c的代码，但是会出现编译通过，运行失败的问题。
//在C++中：
const修饰的常量不可以被修改，应去掉const修饰词

c++的打印

c++可以运行c的代码，反之，c不能加载C++的代码

//C++的日志输出， <<并不是运算符，只是操作符重载， endl相当于c中的 \n;
 //以下语句相当于  printf("c++学习 \n");
 cout << "c++学习" << endl;

 

指针引用：&

• 不采用&，这连个函数的地址不同
• 采用&后，引用的同个内存地址

int number = 100;
int & num2 = number;
//num2 和 number 指针指向同个地址。一旦该地址值改变，所有的指针都获取同个值
 num2 = 99；

#include <iostream>
using namespace std;

void numChange(int * num1,int * num2){
    int temp = 0;
    temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}

int main(){
    int a = 666;
    int b = 888;
    numChange(&a,&b);
    cout << "a:"<< a << ", b: " << b << endl;
    return 0;
    }
 //log: a:888, b: 666

typedef

可以使用 typedef 为一个已有的类型取一个新的名字

typedef type newname;

静态转换static_cast

注意：静态转换不进行任何运行时类型检查，因此可能会导致运行时错误

int i = 10;
float f = static_cast<float>(i); // 静态将int类型转换为float类型

常量引用

#include <iostream>
#include <cstring>

using namespace std;
//保证代码的统一性
typedef struct{
    char name[20];
    int age;
}Student;

//此时若为s，则打印为 "王大斌"，s和传入的student不是同一地址
//若为&s，则打印为 "隔壁老王"
//若为const Student，则报错，const修饰的变量只读，不可更改
void insertStudent(Student &s){
    //此时s是只读的，不可改变
    strcpy(s.name,"隔壁老王");
}

int main(){
    Student student = {"王大斌",32};
    insertStudent(student);
    cout <<"student  name: "<< student.name <<endl;
    return 0;
}

函数重载

void add(int num1,int num2){}

//c语言中不支持函数重载，c++才支持函数重载
void add(int num1,int num2, int num3){}
//默认形参写法，kt是借鉴于c++
void add( int num1,int num4 = 0){
    
}

注意：调用时会优先寻找带有默认参数的方法执行，跟函数顺序无关

 

先定义参数类型先抽象出来（无形参数），后边再补充逻辑

#include <iostream>
using namespace std;

void JNIMethod(int,double,char ){
    cout << "先定义好，后边再升级" ;
}

int main()
{
   cout << "Hello World" << endl;
    JNIMethod(1,0.1,'1');
   return 0;
}

//Student.h只写声明，不写实现；类似java的接口
#include <iostream>
using namespage std;

class Student {
private://从这里之下的代码(成员和函数)都是私有的
    int age;
    char* sex;
public://从这里之下的代码(成员和函数)都是公有的
    void  setAge(int age)；
    void  setSex(char *sex);
    int getAge();
}

//Student.cpp  写实现
#include "Student.h"

void Student::setAge(int age){
    this -> age = age;
}
。。。。。。

//使用
#include "Student.h"
int main(){
    //打印
    std::cout << age << std::endl;
    ===============栈内开辟空间====================================
    Student studetnStack;
    studetnStack.setAge(1);
    cout << age << sex << endl;
    
     ===============栈内开辟空间====================================
     
     Student * studentdump = new Student();
     studentdump.setAge(88);
     //注意 new 和 delete对应。
     
     delete studentdump;//表示销毁堆内分配的对象，必须执行此操作，否则会堆内存溢出。
     studentdump = NULL；
}

 

构造函数和析构函数

构造函数：注意malloc时不会执行构造函数，所以请使用new创建对象

析构函数：~XX()，波浪线

 

#include <iostream>

using namespace std;

class Student{


private:
   int age;
   char* sex;

public:
    void setAge(int age);
    void setSex(char * sex);
    int getAge();
    char* getSex();
    Student(){
        cout<< "我是默认无参构造函数" << endl;
    }
    Student(int age): Student(age,'男'){
        cout<< "我是一个参构造函数, age: "<< age << endl;
    }

    Student(int age, char* sex){
        cout<< "我是两个参构造函数, age: "<< age << "  , sex: "<< sex << endl;
        this->age = age;
        this->sex = sex;
    }
        //此代码等同上边代码，简写方法
      //    Student(int age,char* sex) : sex(sex),age(age) {}
    //当delete时，析构函数一定会执行
    ~Student(){
        //可以执行释放工作
    }
};
//注意，在java中，可以通过finalize()，java调用次函数，有可能会被回收，打上被回收的标记，放入队列中，并不是一定会被回收了