GO语言复合类型01---指针

package main

/*
%T 类型占位符
%v 值占位符
%p 地址(指针)占位符,只有地址才能替换%p
&value 对值取地址
*addr 对地址取值
**int 指向int型指针的指针
作用:函数传参时,传递指针叫引用传递,值传递是拷贝式的,对被传参数的修改是不会改变本体的,想要改变本体只能是引用传递
*/

import "fmt"

//指针就是地址
//&value 对值取地址
//*ptr 对地址取值
func main021() {

	//声明变量a时,系统开辟了一块内存【地址】,里面存的【值】是123
	var a int = 123
	fmt.Printf("a的类型是%T\n", a)//int
	fmt.Printf("a的值是%v\n", a)//123
	fmt.Printf("a的地址是%p\n", &a)//0x...

	//&a取变量a的地址
	aPointer := &a
	fmt.Printf("aPointer的类型是%T\n",aPointer)//*int

	//将aPointer指向的地址中的值修改为456
	*aPointer = 456
	fmt.Println("*aPointer=",*aPointer)//456
	//a的值就变成了456
	fmt.Println("a=",a)
}

//先定义原始变量,修改其指针中的值,会直接改变原变量
//指针如果没有重新赋值,永远指向同一块地址
func main022() {

	//系统给x分配了内存
	var x = 456
	fmt.Println(x)//456

	//定义整型指针(存储整型数据的地址)
	//默认赋值为空<nil>
	var xPtr *int
	fmt.Println("xPtr=", xPtr)//nil

	//aPtr指向x的地址
	xPtr = &x

	//将xPtr指向的地址中的值修改为789
	*xPtr = 789

	fmt.Println(x)         //789
	fmt.Println(xPtr)      //0xc042052080
	fmt.Println(&x)        //0xc042052080
	fmt.Println(*xPtr)     //789
	fmt.Println(*xPtr == x) //true
	fmt.Println(xPtr == &x) //true

	var y = 456
	*xPtr = y
	fmt.Println(x)          //456
	fmt.Println(xPtr)       //没有变
	fmt.Println(&x)         //没有变
	fmt.Println(*xPtr)      //456
	fmt.Println(*xPtr == y) //true
	fmt.Println(x == y)     //true
	fmt.Println(&x == &y)   //false
	fmt.Println(xPtr == &y) //false
	fmt.Printf("y的地址是%p\n",&y)

	fmt.Println("----------")
	//xPtr指向y的地址
	xPtr = &y
	y = 789
	fmt.Println(x)      //456
	fmt.Println(y)      //789
	fmt.Println(*xPtr)	//789
	fmt.Println(&x == xPtr) //false
}

//指针是严格检测数据类型的
func main023() {
	var x = 123
	var intPtr *int
	intPtr = &x
	fmt.Println(intPtr, *intPtr) //0x...,123

	//var y = "你妹"
	//intPtr = &y//编译错误,【整型指针】无法赋值为【字符串的地址】
}

//指针的指针
func main024() {
	var x = 123
	var mPtr *int = &x

	//var mmp **int
	mmPtr := &mPtr
	fmt.Println(mmPtr)//0xc042072018
	fmt.Printf("mmPtr的类型是%T\n",mmPtr)//mmPtr的类型是**int

	//打印x的值
	fmt.Println(*mPtr)//123
	fmt.Println(*(*mmPtr))//123
	fmt.Println(**mmPtr)//123
}

func main() {
	//main021()
	//main022()
	//main023()
	main024()
}

  

原文地址:https://www.cnblogs.com/yunweiqiang/p/11809002.html

时间: 2024-10-19 15:05:39

GO语言复合类型01---指针的相关文章

实验c语言不同类型的指针互用(不推荐只是学习用)

#include <stdio.h> int main(int argc, char *argv[]) { printf("Hello, world\n"); char c[4]; int *p = NULL; p = (int *)(&c[0]); *p = 0X01020304; printf("%d--%d--%d--%d--",c[0],c[1],c[2],c[3]); return 0; } 结果是:4--3--2--1 指针步长,字符

GO语言复合类型04---映射

package main import "fmt" /* 映射(map)是键值对(key-value)数据的集合 根据键key可以快速检索值value 键值的类型可以是任意的,key使用string的时候最多 */ //创建和访问键值 func main051() { //定义string为键int为值的映射,用于存储分数 //var scoreMap map[string]int = map[string]int{} //var scoreMap = map[string]int{}

Go语言学习笔记(4)复合类型

  Go语言的复合类型,包括数组.切片和映射等. 值.指针和引用类型 通常情况下Go语言中的变量持有相应的值.也就是说,我们可以将一个变量想象成它所持有的值来使用.其中有些例外,通道.函数.方法.映射.切片是 引用变量,它们持有的都是引用,也即保存指针的变量.值在传递给函数或者方法的时候会被复制一次,对于布尔类型和数值类型来说这非常廉价,但是对于大型变 量代价却非常大.而且复制传参的方式,修改值只是修改了副本,这能保证原始变量不被修改,但也一定程度上增加了修改原始值的麻烦.幸好在Go语言中有指

黑马程序员-C语言基础:指针类型与指针和数组、字符串的关系

//指针变量就是用来存储地址的,只能存储地址 格式:  int  *p;  这个p为指针变量:指针变量占8个字节 类型是用来说明这个指针指向的类型: 比如上边的int代表这个指针变量会指向int类型的存储空间: int *p = &a;//这样一句可以写,此时的*只是一个标志,表示这个*只是表示p是个指针: *p = &a;//这样写就错了:此时*p表示取p指向的空间的值: 指针疑问:指针既然都占据8个字节,那么为什么要划分类型, 是因为当用*p指针取值或者赋值的时候,知道该取几个字节,比

C++数组,指针,引用以及三者的复合类型

C++数组,指针,引用以及三者的复合类型 这里省去了对这三者的单独介绍,仅仅介绍使用这三者组成的组合类型. 一.两两组合 这三者的两两组合有9种: 数组 指针 引用 数组 数组的数组 数组的指针 数组的引用 指针 指针的数组 指针的指针 指针的引用 引用 引用的数组 引用的指针 引用的引用 1.指针的指针.数组的数组.数组的指针.指针的数组 指针的指针(二维指针),数组的数组(二维数组),数组的指针和指针的数组这里就不介绍了,很多博客文章书籍都有详细的介绍.它们的形式是: 指针的指针: int*

go语言学习四 - 复合类型字面量声明

package main import ( "encoding/json" "fmt" ) func main() { //go语言的复合大括号文面量声明非常强大和灵活 //只要在最外层声明完整的复合类型在大括号内部就不需要再声明类型而直接用大括号了 a := [][]int{ {1, 2, 3, 4}, //这里不必再用 []int{1,2,3,4} 声明,如果用的话编译器提示冗余的类型声明(Redundant type declaration) {5, 6, 7

C语言 详解多级指针与指针类型的关系

//通常意义上,指针类型指的是‘指针值’的类型,而不是‘指针’的类型 //V推论①:变量的步长只与变量的类型有关 //普通变量名是一段内存空间的标识,普通变量名代表的是一段内存空间, //对于复杂变量(例如指针):通常的指针的步长准确来说是指‘指针值’的步长,而不是指‘指针本身’的步长,指针本身的步长永远是4, //我们通常说的指针类型往往指的是‘指针值’的类型,,而不是‘指针’的类型 //而指针类型就是一个占4个字节大小内存空间的一种类型(从来没有人定义过指针类型,人们定义的都是‘指针值’的类

第四章 复合类型

第四章  复合类型 4.1  数组 4.1.1  数组简介 数组(array)是一种数据格式,能够存储多个同类型的值. 声明数组的通用格式如下: typeName arrayName[arraySize]; 表达式arraySize指定数组的元素数目,它只能是以下三种情况之一: 1)        整型常数(如10,枚举值也可以): 2)        const值 3)        常量表达式(如8 * sizeof(int)) 注意:使用数组要注意下标的正确.编译器不会检查使用的下标是否有

《c++primer笔记》复合类型--引用

复合类型:基于其他类型定义的语言 这里介绍两种 引用 指针 声明语句:一个基本数据类型,一个声明符列表组成 引用:为对象起另外一个名字 引用类型:引用另外一种类型 int ival = 1024; int &refVal = ival;        //refVal指向ival(是ival的另一个名字) int &refVal2;              //报错,引用必须被初始化 一般初始化变量:初始值会被拷贝到新建的对象中 定义引用:把引用和他的初始值绑定在一起,而不是拷贝给引用.